Algorithms and Data Structures

Exercise for the Final Exam (17 June 2014)

Stack, Queue, Lists, Trees, Heap

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.

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;

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;
}

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.

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;
}
}

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);
}
}
}

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);

Doubly linked list

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);

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;
}
}

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;

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);

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

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.

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;
}

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.

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

if ((root->right != NULL) &&

(root->right->element > root->element))
return 0;
return isHeap(root->left) && isHeap(root->right);
}

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:
5

Solution:

6
7

7
6

6
5

7
6

8
6

8
6

8
6

9
6

7
5

6
5

8
6

8
6

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:
27
49 35
19 87 53 67
29

27
49 35
29 87 53 67
19

27
49 67
29 87 53 35
19

27
87 67
29 49 53 35
19

87
27 67
29 49 53 35
19
Heap:
87
49 67
29 27 53 35
19

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

23

15

23

15

23

23

15

15

11

23

15

11

40

40

40

23

11

23

15

11

15

Heap (3)
40

23

11

15

90

90

23

11

40

15

Heap (4)
The given heap is stored in the array:
93

82

47

31

llustrate the ascending heapsort.

64

23

17

27

Solution (1/8)
Initial heap:

93

93 82 47 31 64 23 17 27
82

31

47

64

23

17

27

Replace the element from the top of the heap with the last element from the unsorted array part:

27

82

47

27 82 47 31 64 23 17 93
31

64

23

17

Solution 2/8
Adjust the heap:

82

64

82 64 47 31 27 23 17 93

47

31

27

23

17

Replace the element from the top of the heap with the last element from the unsorted array part:

17

64

31

47

27

23

17 64 47 31 27 23 82 93

Solution 3/8
Adjust the heap:
64

31

64 31 47 17 27 23 82 93

47

17

27

23

Replace the element from the top of the heap with the last element from the unsorted array part:

23

31

17

47

27

23 31 47 17 27 64 82 93

Solution 4/8
Adjust the heap:
47

31

47 31 23 17 27 64 82 93

23

17

27

Replace the element from the top of the heap with the last element from the unsorted array part:

27

31

17

23

27 31 23 17 47 64 82 93

Solution 5/8
Adjust the heap:
31

31 27 23 17 47 64 82 93
27

23

17

Replace the element from the top of the heap with the last element from the unsorted array part:

17

17 27 23 31 47 64 82 93
27

23

Solution 6/8
Adjust the heap:

27

27 17 23 31 47 64 82 93
17

23

Replace the element from the top of the heap with the last element from the unsorted array part:

23

23 17 27 31 47 64 82 93
17

Solution 7/8
Adjust the heap:

23

23 17 27 31 47 64 82 93
17

Replace the element from the top of the heap with the last element from the unsorted array part:

17

17 23 27 31 47 64 82 93

Solution 8/8

Sorted array:
17

23

27

31

47

64

82

93