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

Doubly linked list

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;

}

}

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

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;

}

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.

Trees (2)

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;

}

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.

Heap (1)

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

8

6

7 56

7

9

5

8

6

9 56

7

7

5

7

6

9 56

8

7

5

7

9

6 56

8

7

5

7

9

7 56

8

6

9

7

5

7 56

8

6

9

7

7

5 56

8

6

9

7

7

6 56

8

5

Solution:

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:

Heap (2)

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

Solution:27

49 35

19 87 53 67

29

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:

Heap (3)

15

23

15

15

23

15 7

23

15

11

7

23

15

4011

7

23

23

1511

7

40

23

1511

7

5

40

Solution:

Heap (3)

23

1511

7

905

40

23

1511

40

75

90

The given heap is stored in the array:

llustrate the ascending heapsort.

Heap (4)

93 82 47 31 64 23 17 27

Solution (1/8)

Initial heap:

27

82

6431

47

1723

93

93 82 47 31 64 23 17 27

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

82

6431

47

1723

27

27 82 47 31 64 23 17 93

Solution 2/8

Adjust the heap:

64

2731

47

1723

82

82 64 47 31 27 23 17 93

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

64

2731

47

23

17

17 64 47 31 27 23 82 93

Solution 3/8

Adjust the heap:

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

31

2717

47

23

64

64 31 47 17 27 23 82 93

31

2717

47

23

23 31 47 17 27 64 82 93

Solution 4/8

Adjust the heap:

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

31

2717

23

47

47 31 23 17 27 64 82 93

31

17

23

27

27 31 23 17 47 64 82 93

Solution 5/8

Adjust the heap:

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

27

17

23

31

31 27 23 17 47 64 82 93

27 23

17

17 27 23 31 47 64 82 93

Solution 6/8

Adjust the heap:

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

17 23

27

27 17 23 31 47 64 82 93

17

23

23 17 27 31 47 64 82 93

Solution 7/8

Adjust the heap:

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

17

23

23 17 27 31 47 64 82 93

17

17 23 27 31 47 64 82 93

Solution 8/8

Sorted array:

17 23 27 31 47 64 82 93