Algorithms and Data Structures Exercise for the Final Exam (17 June 2014) Stack, Queue, Lists, Trees, Heap

Transcription

1 Algorithms and Data Structures Exercise for the Final Exam (17 June 2014) Stack, Queue, Lists, Trees, Heap

2 Singly linked list (1) Data about exam results are stored into a singly linked list. Each list element consists of: student name(50+1 character) student ID (int) course code (int) grade (int) The list is not sorted. Write the function that removes students with negative grades (those with grade 1) from the list. The function returns the number of removed list members. Write the corresponding struct.

3 Solution (1/2) struct record { char name[50+1]; int id; int code; int grade; ; struct at { struct record element; struct at *next ; typedef struct at atom;

4 Solution (2/2) int removenegative(atom **head){ int removed = 0; atom *tmp; while(*head) { if ((*head)->element.grade == 1) { removed++; tmp = *head; *head = (*head)->next; free(tmp); else { head = &((*head)->next); return removed;

5 Singly linked list (2) Write the function that removes even numbers from the list that contains integers. At the beginning, the head from the function points to the head from the main program, then it points to pointers sljed, all of which are struct members. If the first node contains even number, then the statement: *glava=(*glava)->sljed; changes the pointer head from the main program, otherwise it changes pointer sljed which is the struct member.

6 Solution 1 with an auxiliary pointer for the previous atom void remove Even(atom **head) { atom *old; atom *tmp = *head; while ((tmp!= NULL) && (tmp->element % 2 == 0)) { tmp = (*head)->next; free (*head); *head = tmp; while (tmp!= NULL) { while ((tmp-> next!= NULL) && ((tmp-> next)->element % 2!= 0)) tmp = tmp-> next; if (tmp-> next!= NULL) { old = tmp-> next; tmp-> next = old-> next; free(old); else tmp = tmp-> next;

7 Solution 2 without an auxiliary pointer for the previous atom void removeeven(atom **headp){ int removed = 0; atom *tmp; while(*headp) { if (!((*headp)->element % 2)) { tmp = *headp; *headp = (*headp)->next; free(tmp); else { headp = &((*headp)->next);

8 Singly linked list (3) - homework Given the two lists sorted in an ascending order, write the recursive function that merges the two lists into one list, also sorted in the ascending order. Return that list into the main program. The protptype of the function is: atom *merge(atom *h1, atom *h2);

9 Doubly linked list

10 Doubly linked list Doubly linked list contains data about students, sorted in a descending order (from head) according to the average grades. The list is defined with the following structures: struct record { char name[80+1]; float avggrade; ; struct at { struct record element; struct at *next; struct at *prev; ; typedef struct at atom; Write the function that reverses the order of elements in the doubly linked list. The prototype of the function is: void reverselist(atom **head, atom **tail);

11 Solution void reverselist(atom **head, atom **tail){ atom *aux,*aux1; aux = *head; *head = *tail; *tail = aux; while(aux!= NULL){ aux1 = aux->next; aux->next = aux->prev; aux->prev = aux1; aux = aux->prev;

12 Trees Tree containing data about products (name and price) is given with the following structures: typedef struct { char name[20]; float price; Element; struct n{ Element element; struct n *left, *right; ; typedef struct n node;

13 Trees (1) Write the function that will change the given tree into its mirror copy (for each node replace its left and right child). The prototype of the function is: node *mirrortree (node *root);

14 Solution node *mirrortree(node *root){ if (root){ node *tmp; tmp = root->left; root->left = mirrortree(root->right); root->right = mirrortree(tmp); return root;

15 Trees (2) A binary search tree is sorted according to the price. Write the function with the prototype: int search(node *root, float price); The function returns 1 if the tree contains the product with the searched price, otherwise it returns 0.

16 Solution int search(node *root, float price){ if (root){ if (price == root->element.price) return 1; else if (price < root->element.price) return search(root->left, price); else return search(root->right, price); return 0;

17 Heap (1) Write the function with the prototype int isheap(node *root); The function returns 1 if the complete binary tree (with the given root) is heap, otherwise it returns 0.

18 Solution int isheap(node *root){ if (root == NULL) return 1; if ((root->left!=null) && return 0; (root>left->element > root->element)) if ((root->right!= NULL) && return 0; (root->right->element > root->element)) return isheap(root->left) && isheap(root->right);

19 Heap(1) Assuming a heap is created for the following input sequence: 5, 6, 7, 7, 6, 8, 5, 9, using the algorithm with O(n) running time in the worst case, illustrate all the steps of the creation process: Solution:

20 Heap (2) Assuming a heap is created for the following input sequence: 27, 49, 35, 19, 87, 53, 67, 29, using the algorithm with O(n) running time in the worst case, illustrate all the steps of the creation process: Solution: Heap:

21 Heap (3) Assuming a heap is created for the following input sequence: 15,, 7, 11, 40, 5, 90, using the algorithm with O(nlog 2 n) runnning time in the worst case, illustrate all the steps of the creation process: Solution:

22 Heap (3)

23 Heap (4) The given heap is stored in the array: llustrate the ascending heapsort.

24 Solution (1/8) Initial heap: Replace the element from the top of the heap with the last element from the unsorted array part:

25 Solution 2/8 Adjust the heap: Replace the element from the top of the heap with the last element from the unsorted array part:

26 Solution 3/8 Adjust the heap: Replace the element from the top of the heap with the last element from the unsorted array part:

27 Solution 4/8 Adjust the heap: Replace the element from the top of the heap with the last element from the unsorted array part:

28 Solution 5/8 Adjust the heap: Replace the element from the top of the heap with the last element from the unsorted array part:

29 Solution 6/8 Adjust the heap: Replace the element from the top of the heap with the last element from the unsorted array part:

30 Solution 7/8 Adjust the heap: Replace the element from the top of the heap with the last element from the unsorted array part:

31 Solution 8/8 Sorted array: