Kopiec
      
        void heapRestore(heap *inputHeap, int i) {
    int l = left(i);
    int r = right(i);
    int najwiekszy;
    if(l<=inputHeap->heapSize&&inputHeap->A[l]>inputHeap->A[i]){
        najwiekszy = l;
    }
    else{
        najwiekszy = i;
    }
    if(r<=inputHeap->heapSize&&inputHeap->A[r]>inputHeap->A[najwiekszy]){
        najwiekszy = r;
    }
    if(najwiekszy!=i){
        int tym = inputHeap->A[i];
        inputHeap ->A[i] = inputHeap->A[najwiekszy];
        inputHeap->A[najwiekszy] = tym;
        heapRestore(inputHeap,i);
    }
}

void heapBuild(heap *inputHeap, int *table, int length) {
    inputHeap->heapSize = length;
    for(int i=length/2;i>0;i--){
        heapRestore(inputHeap,i);
    }
}

int kopiecUsunMax(heap *inputHeap){
    if(inputHeap->heapSize<1){
        printf("Blad kopiec jest pusty");
        return 1;
    }
    int max = inputHeap->A[1];
    inputHeap->A[1] = inputHeap->A[inputHeap->heapSize];
    inputHeap->heapSize--;
    heapRestore(inputHeap,1);
    return max;
}

void kopiecWstaw(heap *inputHeap,int key){
    inputHeap->heapSize++;
    int i = inputHeap->heapSize;

    while(i>1 && inputHeap->A[parent(i)]A[i] = inputHeap->A[parent(i)];
        i = parent(i);
    }
    inputHeap->A[i] = key;
}
      
      Lista
			
	ListNode * listFind(const DoubleLinkedList * list, const Finger * finger) {

    ListNode * current = list->head;

    while (!fingersEqual(¤t->data, finger)) {
        current = current->next;
    }

    return current;
}

ListNode * listInsert(DoubleLinkedList * list, ListNode * newNode) {
    newNode->next = list->head;

    if (NULL != list->head) {
        list->head->previous = newNode;
    }

    list->head = newNode;
    newNode->previous = NULL;
}

void listRemove(DoubleLinkedList * list, ListNode * nodeToRemove) {
    ListNode * nodeExists = listFind(list, &nodeToRemove->data) != NULL;

    // Node not present in list
    if (!nodeExists) {
       return;
    }

    nodeToRemove->previous->next = nodeToRemove->next;
    nodeToRemove->next->previous = nodeToRemove->previous;

    nodeToRemove = NULL;
}
			
			Stos
			
	void push(Stack *stack, const Finger *finger) EXC_THROWS(stack_overflow)
	{
		if (stack->top >= STACK_LAST_ELEMENT_INDEX) {
			EXC_THROW(stack_overflow);
		}
		if (stack->top < STACK_EMPTY_INDEX) {
			EXC_THROW(stack_underflow);
		}
		stack->top++;
		stack->buffer[stack->top] = *finger;
	}

	Finger *pop(Stack *stack) EXC_THROWS(stack_underflow)
	{
		if (stack->top < 0) {
			EXC_THROW(stack_underflow);
		}
		if (stack->top > STACK_LAST_ELEMENT_INDEX) {
			EXC_THROW(stack_overflow);
		}
		stack->top--;
		return &stack->buffer[stack->top + 1];
	}
			
			Kolejka
			
	void enqueue(Queue *queue, const Finger *finger)
	{
		if (queue->tail > QUEUE_LAST_ELEMENT_INDEX) {
			EXC_THROW(queue_overflow);
		}
		if (queue->tail < QUEUE_FIRST_INDEX) {
			EXC_THROW(queue_underflow);
		}
		if (queue->head == queue->tail + 1) {
			EXC_THROW(queue_overflow);
		}
		queue->buffer[queue->tail] = *finger;
		if (queue->tail == QUEUE_LAST_ELEMENT_INDEX) {
			queue->tail = QUEUE_FIRST_INDEX;
		} else {
			queue->tail++;
		}
	}

	Finger *dequeue(Queue *queue)
	{
		if (queue->head > QUEUE_LAST_ELEMENT_INDEX) {
			EXC_THROW(queue_overflow);
		}
		if (queue->head < QUEUE_FIRST_INDEX) {
			EXC_THROW(queue_underflow);
		}
		if (queue->head == queue->tail) {
			EXC_THROW(queue_underflow);
		}
		Finger *finger = &queue->buffer[queue->head];
		if (queue->head == QUEUE_LAST_ELEMENT_INDEX) {
			queue->head = QUEUE_FIRST_INDEX;
		} else {
			queue->head++;
		}
		return finger;
	}
			
      Drzewo
      
  tnode *bstAdd(tnode *root, tnode *newLeaf) {
  if (root == NULL) {
    return newLeaf;
  }
  tnode *current = root;
  tnode *parent = NULL;
  // Iteracyjne przejście przez drzewo (odpowiednik algorytmu K3.6 ze skryptu)
  while (current != NULL) {
    parent = current;
    if (newLeaf->val < current->val) {
      current = current->left;
    } else if (newLeaf->val > current->val) {
      current = current->right;
    } else {
      // Element o podanym kluczu już istnieje w drzewie
      return root;
    }
  }
  // Podpięcie nowego węzła
  if (newLeaf->val < parent->val) {
    parent->left = newLeaf;
  } else {
    parent->right = newLeaf;
  }
  return root;
}

 tnode *root = NULL;

 srand(time(NULL));
 for (int i = 0; i < 10; i++) {
 tnode *newLeaf = (tnode*)malloc(sizeof(tnode));
 if (newLeaf != NULL) {
 newLeaf->val = rand() % 100 + 1; // Klucze losowe od 1 do 100
 newLeaf->left = NULL;
 newLeaf->right = NULL;
 root = bstAdd(root, newLeaf);
 }
 }
 print_t(root);
 return 0;
}

tnode* bstCreateNode(int value, const char* imie, const char* nazwisko) {
 tnode *newNode = (tnode*)malloc(sizeof(tnode));
 if (newNode != NULL) {
 newNode->val = value;
 strncpy(newNode->imie, imie, sizeof(newNode->imie) - 1);
 newNode->imie[sizeof(newNode->imie) - 1] = '\0';
 strncpy(newNode->nazwisko, nazwisko, sizeof(newNode->nazwisko) - 1);
 newNode->nazwisko[sizeof(newNode->nazwisko) - 1] = '\0';
 newNode->left = NULL;
 newNode->right = NULL;
 }
 return newNode;
}
        
		

Emulator maszyny RAM

Autor pracy:

Łukasz Janik