Note : below all experiments viva questions have been given

EE2209 - DATA STRUCTURES AND ALGORITHMS

LABORATORY

LAB MANUAL

Department of Information Technology,

Rajalakshmi Engineering College,

Thandalam.

2

INDEX

I LAB SYLLABUS

II LAB PLAN

III PSEUDO CODES FOR LAB EXPERIMENTS

1. (a) Implementation of Linked List

(b) Implementation of Doubly Linked list

2. Represent a polynomial as a linked list and write functions For polynomial addition.

3. Implementation of tree traversal

4. Implementation of stack ( infix to postfix conversion)

5. Implementation of Binary search Tree

6. Implementation of insertion in AVL trees

7. Implementation of hashing techniques

8. Implementation of backtracking algorithm for knapsack

problem

9. Implementation of prim’s and kruskal’s algorithm

10. Implementation of dijktra’s algorithm using priority queues

3

11. Implementation of array based circular queue

12. Implementation of priority queues using heaps

13. Implementation of branch and bound algorithm

14. Implementation of Randomized algorithm

15. Implementation of Topological sort on a Directed graph to decide is it is cyclic

4

EE2209 DATA STRUCTURES AND ALGORITHMS LABORATORY 0 0 3 2

(Common to EEE, EIE& ICE) Aim: To develop skills in design and implementation of data structures and their applications.

1. Implement singly and doubly linked lists. 2. Represent a polynomial as a linked list and write functions for polynomial

addition. 3. Implement stack and use it to convert infix to postfix expression 4. Implement array-based circular queue and use it to simulate a producer-consumer

problem. 5. Implement an expression tree. Produce its pre-order, in-order, and post-order

traversals. 6. Implement binary search tree. 7. Implement insertion in AVL trees. 8. Implement priority queue using heaps 9. Implement hashing techniques 10. Perform topological sort on a directed graph to decide if it is acyclic. 11. Implement Dijkstra's algorithm using priority queues 12. Implement Prim's and Kruskal's algorithms 13. Implement a backtracking algorithm for Knapsack problem 14. Implement a branch and bound algorithm for traveling salesperson problem 15. Implement any randomized algorithm.

TOTAL : 45 PERIODS

5

LAB PLAN

SI.No Name of the Experiment Date 1 (a) Implementation of

Linked List (b) Implementation of

Doubly Linked List

2 Represent a polynomial as a linked list and write functions for polynomial addition.

3 Implementation of tree traversal

4 Implementation of stack (converting infix to postfix expression)

5 Implementation of Binary search tree

6 Implementation of hashing techniques

7 Implementation of insertion in AVL Tree

8 Implementation of Backtracking algorithm for Knapsack problem

9 Implementation of Prim’s and Kruskal’s algorithm

10 Implementation of Dijktra’s algorithm using priority queues

11 Implementation of array based circular queue

12 Implementation of priority queues using heaps

13 Implementation of Branch and bound algorithm

14 Implementation of Randomized algorithm

15 Implementation of Topological sort on a

6

Directed graph to decide is it is cyclic

7

IMPLEMENTATION OF A LINKED LIST Ex. No : 1(a)

AIM:

To implement a linked list and do all operations on it.

ALGORITHM: Step 1: Start the process. Step 2: Initialize and declare variables. Step 3: Enter the choice. INSERT / DELETE. Step 4: If choice is INSERT then

a) Enter the element to be inserted. b) Get a new node and set DATA[NEWNODE] = ITEM.

c) Find the node after which the new node is to be inserted.

d) Adjust the link fields.

e) Print the linked list after insertion.

Step 5: If choice is DELETE then

a) Enter the element to be deleted.

b) Find the node containing the element (LOC) and its preceding node (PAR).

c) Set ITEM = DATA [LOC] and delete the node LOC.

d) Adjust the link fields so that PAR points to the next element. ie LINK [PAR] = LINK [LOC].

e) Print the linked list after deletion. Step 6: Stop the process.

8

IMPLEMENTATION OF DOUBLY LINKED LIST Ex. No : 1(b)

AIM: To implement a doubly linked list and do all operations on it.

ALGORITHM:

Step 1: Data type declarations

record Node { data prev } record List { Node firstNode // points to first node of list; null for empty list Node lastNode // points to last node of list; null for empty list }

Step 2: Iterating over the nodes

Iterating through a doubly linked list can be done in either direction. In fact, direction can change many times, if desired.

node := list.firstNode while node ≠ null <do something with node.data> node := node.next node := list.lastNode while node ≠ null <do something with node.data> node := node.prev

Step 3:Inserting a node

function insertAfter(List list, Node node, Node newNode) newNode.prev := node newNode.next := node.next if node.next == null list.lastNode := newNode else node.next.prev := newNode node.next := newNode function insertBefore(List list, Node node, Node newNode) newNode.prev := node.prev newNode.next := node if node.prev is null list.firstNode := newNode

9

else node.prev.next := newNode node.prev := newNode

Function to insert a node at the beginning of a possibly-empty list:

function insertBeginning(List list, Node newNode) if list.firstNode == null list.firstNode := newNode list.lastNode := newNode newNode.prev := null newNode.next := null else insertBefore(list, list.firstNode, newNode)

A symmetric function inserts at the end:

function insertEnd(List list, Node newNode) if list.lastNode == null insertBeginning(list, newNode) else insertAfter(list, list.lastNode, newNode)

Step 5:Deleting a node

Removing a node is easier, only requiring care with the firstNode and lastNode:

function remove(List list, Node node) if node.prev == null list.firstNode := node.next else node.prev.next := node.next if node.next == null list.lastNode := node.prev else node.next.prev := node.prev destroy node

Viva Questions:

A Linked list can grow and shrink in size dynamically at _______.

Write an algorithm to detect loop in a linked list.

Reverse a linked list.

Delete an element from a doubly linked list.

Implement an algorithm to reverse a singly linked list. (with and without

recursion)

Implement an algorithm to reverse a doubly linked list

10

How would you find a cycle in a linked list? Try to do it in O(n) time. Try it using

a constant amount of memory.

REPRESENT A POLYNOMIAL AS LINKED LIST AND IMPLEMENT

POLYNOMIAL ADDITION

Ex. No: 2

AIM:

To represent polynomial as linked list and perform polynomial addition.

ALGORITHM: Step 1: Creating Node. /*Inserting an element in a sorted linked list. Let the data be sorted and put in a singly linked linear list which is being pointed by address “head “.Let the new data to be entered be “d”.Use malloc get a node with address “pNew”. Suppose we want to write a code to enter data “d” into the node and insert it into its proper place in the list.*/ typedef struct node { int data; struct node *next; }; struct node* pNew = (struct node*) (malloc(sizeof(struct node))); pNew -> data = d; pNew ->next = NULL; pCur = head ; /* check if data is smaller than smallest item on the list*/ if (pNew -> data < pCur -> data ) { pNew ->next = pCur ; head = pNew; } /* now examine the remaining list */ p = pCur -> next ; while(p!=NULL ||p->data < pNew->data ) { pCur = pCur -> next ; p = p -> next ; } pNew -> next = pCur -> next; pCur -> next = pNew ; A polynomial can be represented in an array or in a linked list by simply storing the coefficient and exponent of each term. However, for any polynomial operation, such as addition or multiplication of polynomials, Step 2: Addition of two polynomials

11

Consider addition of the following polynomials 5 x12 + 2 x9 + 4x7 + 6x6 + x3 7 x8 + 2 x7 + 8x6 + 6x4 + 2x2 + 3 x + 40 The resulting polynomial is going to be 5 x12 + 2 x9 + 7 x8 + 6 x7 + 14x6 + 6x4 +x3 2x2 + 3 x + 40 Step 3: Result of addition is going to be stored in a third list. Step 4: Started with the highest power in any polynomial. Step 5: If there was no item having same exponent, simply appended the term to the new list, and continued with the process. Step 6: Wherever the exponents were matching, simply added the coefficients and then stored the term in the new list. Step 6: If one list gets exhausted earlier and the other list still contains some lower order terms, then simply append the remaining terms to the new list. //Pseudo code Let phead1 , phead2 and phead3 represent the pointers of the three lists under consideration. Let each node contain two integers exp and coff . Let us assume that the two linked lists already contain relevant data about the two polynomials. Also assume that we have got a function append to insert a new node at the end of the given list. p1 = phead1; p2 = phead2; Let us call malloc to create a new node p3 to build the third list p3 = phead3; /* now traverse the lists till one list gets exhausted */ while ((p1 != NULL) || (p2 != NULL)) { / * if the exponent of p1 is higher than that of p2 then the next term in final list is going to be the node of p1* / while (p1 ->exp > p2 -> exp ) { p3 -> exp = p1 -> exp; p3 -> coff = p1 -> coff ; append (p3, phead3); /* now move to the next term in list 1*/ p1 = p1 -> next; } / * if p2 exponent turns out to be higher then make p3 same as p2 and append to final list * / while (p1 ->exp < p2 -> exp ) { p3 -> exp = p2 -> exp; p3 -> coff = p2 -> coff ; append (p3, phead3); p2 = p2 -> next; } /* now consider the possibility that both exponents are same , then we must add the coefficients to get the term for

12

the final list */ while (p1 ->exp = p2 -> exp ) { p3-> exp = p1-> exp; p3->coff = p1->coff + p2-> coff ; append (p3, phead3) ; p1 = p1->next ; p2 = p2->next ; } } /* now consider the possibility that list2 gets exhausted, and there are terms remaining only in list1. So all those terms have to be appended to end of list3. However, you do not have to do it term by term, as p1 is already pointing to remaining terms, so simply append the pointer p1 to phead3 */ if ( p1 != NULL) append (p1, phead3) ; else append (p2, phead3);

13

.

IMPLEMENTATION OF TREE TRAVERSALS Ex. No. :3

Date :

AIM: To implement tree traversals using linked list. ALGORITHM: Step 1: Start the process. Step 2: Initialize and declare variables. Step 3: Enter the choice. Inorder / Preorder / Postorder. Step 4: If choice is Inorder then

a) Traverse the left subtree in inorder. b) Process the root node. c) Traverse the right subtree in inorder.

Step 5: If choice is Preorder then

a) Process the root node. b) Traverse the left subtree in preorder. c) Traverse the right subtree in preorder.

Step 6: If choice is postorder then

a) Traverse the left subtree in postorder. b) Traverse the right subtree in postorder. c) Process the root node.

Step7: Print the Inorder / Preorder / Postorder traversal. Step 8: Stop the process. Viva Questions:

Write a function and the node data structure to visit all of the nodes in a binary

tree.

14

What is a balanced tree

Do a breadth first traversal of a tree.

How would you print out the data in a binary tree, level by level, starting at the

top?

Write a function to find the depth of a binary tree.

How do you represent an n-ary tree? Write a program to print the nodes of such a

tree in breadth first order.

What is a spanning Tree?

15

STACK IMPLEMENTATION FOR CONVERTING INFIX TO POSTFIX EXPRESSION

Ex. No. :4

AIM: To implement stack for converting infix to postfix expression ALGORITHM: 1. Start by initializing an empty stack. This will be for holding our operators.

2. Read the string, getting the first operand and add it to the postfix string.

3. Read the next object in the string, normally a operator, and push the operator to the

stack. Is the operator of greater, equal, or lesser precedence than the top most operator on

the stack?

If the operator is greater than the top most operator, push the current operator and

continue.

If the operator is lesser to the top most operator, pop the stack adding it to the

postfix string, and then push the current operator to the stack. Test the next operator to

see if it is also lesser and repeat step 2. If not continue.

If the operator is equal to the top most operator pop the top of the stack adding it to

the postfix string and then push the current operator to the stack.

4. Repeat these steps until all of the operands and operators are taken care of.

5. Afterwards look at the stack one last time to see if any operators remain, pop them all

and add them to the end of the postfix string.

6. Stop the process.

\

Viva questions:

16

Given an expression tree with no parentheses in it, write the program to give

equivalent infix expression with parentheses inserted where necessary.

How would you implement a queue from a stack?

What is stack?

List the difference between queue and stack.

How would you implement a queue from a stack?

17

IMPLEMENTATION OF BINARY SEARCH TREE

Ex. No. :5

AIM:

To implement binary search tree and to do BST operations

ALGORITHM:

find() Operation

//Purpose: find Item X in the Tree

//Inputs: data object X (object to be found), binary-search-tree node node

// Output: bst-node n containing X, if it exists; NULL otherwise.

find(X, node)f if(node = NULL)

return NULL

if(X = node:data)

return node

else if(X < node:data)

return find(X,node:leftChild)

else // X > node:data

return find(X,node:rightChild)

{

findMinimum() Operation

//Purpose: return least data object X in the Tree

//Inputs: binary-search-tree node node

// Output: bst-node n containing least data object X, if it exists; NULL otherwise.

findMin(node)f if(node = NULL) //empty tree

return NULL

if(node:leftChild = NULL)

return node

18

return findMin(node:leftChild)

}

insert() Operation

//Purpose: insert data object X into the Tree

//Inputs: data object X (to be inserted), binary-search-tree node node

//Effect: do nothing if tree already contains X;

// otherwise, update binary search tree by adding a new node containing data object X

insert(X, node)f if(node = NULL)f node = new binaryNode(X,NULL,NULL)

return

{if(X = node:data)

return

else if(X < node:data)

insert(X, node:leftChild)

else // X > node:data

insert(X, node:rightChild)

}

delete() Operation

//Purpose: delete data object X from the Tree

//Inputs: data object X (to be deleted), binary-search-tree node node

//Effect: do nothing if tree does not contain X;

// otherwise, update binary search tree by deleting the node containing data object X

delete(X, node)f if(node = NULL) //nothing to do

return

if(X < node:data)

delete(X, node:leftChild)

else if(X > node:data)

delete(X, node:rightChild)

else f // found the node to be deleted! Take action based on number of node children

if(node:leftChild = NULL and node:rightChild = NULL)f delete node

node = NULL

return

19

{else if(node:leftChild = NULL)f tempNode = node

node = node:rightChild

delete tempNode

{else if(node:rightChild = NULL)f (similar to the case when node:leftChild = NULL)

{else f //replace node:data with minimum data from right subtree

tempNode = findMin(node.rightChild)

node:data = tempNode:data

delete(node:data,node:rightChild)

}

}

}

Viva questions:

What is tree?

What are the advantages of BST?

Write a function and the node data structure to visit all of the nodes in a

binary tree.

20

IMPLEMENTATION OF INSERTION IN AVL TREE

Ex. No. :6

AIM:

To implement Insertion in AVL tree.

ALGORITHM:

int avl_insert(node *treep, value_t target)

{

/* insert the target into the tree, returning 1 on success or 0 if it

* already existed

*/

node tree = *treep;

node *path_top = treep;

while (tree && target != tree->value) {

direction next_step = (target > tree->value);

if (!Balanced(tree)) path_top = treep;

treep = &tree->next[next_step];

tree = *treep;

}

if (tree) return 0;

21

tree = malloc(sizeof(*tree));

tree->next[0] = tree->next[1] = NULL;

tree->longer = NEITHER;

tree->value = target;

*treep = tree;

avl_rebalance(path_top, target);

return 1;

}

void avl_rebalance_path(node path, value_t target)

{

/* Each node in path is currently balanced.

* Until we find target, mark each node as longer

* in the direction of target because we know we have

* inserted target there

*/

while (path && target != path->value) {

direction next_step = (target > path->value); path->longer

node avl_rotate_2(node *path_top, direction dir)

{

node B, C, D, E;

B = *path_top;

D = B->next[dir];

C = D->next[1-dir];

22

E = D->next[dir];

*path_top = D;

D->next[1-dir] = B;

B->next[dir] = C;

B->longer = NEITHER;

D->longer = NEITHER;

return E;

} node avl_rotate_3(node *path_top, direction dir, direction third)

{

node B, F, D, C, E;

B = *path_top;

F = B->next[dir];

D = F->next[1-dir];

/* node: C and E can be NULL */

C = D->next[1-dir];

E = D->next[dir]; *path_top = D; D->next[1-dir] = B; D->next[dir] = F; B->next[dir] = C; F->next[1-dir] = E; D->longer = NEITHER; /* assume both trees are balanced */ B->longer = F->longer = NEITHER; if (third == NEITHER) return NULL; if (third == dir) { /* E holds the insertion so B is unbalanced */ B->longer = 1-dir; return E; } else { /* C holds the insertion so F is unbalanced */ F->longer = dir; return C; } } and there you have an AVL insertion, in non-recursive style, using only constant space, but sometimes performing more comparisons that absolutely needed.

23

IMPLEMENTATION OF HASHING TECHNIQUES

Ex. No. :7

AIM: To implement hashing techniques ALGORITHM:

For insertion:

HASH-INSERT (T, k)

i = 0 Repeat j <-- h(k, i) if Y[j] = NIL then T[j] = k Return j use i = i +1 until i = m error "table overflow"

For Searching:

HASH-SEARCH (T, k)

i = 0 Repeat j <-- h(k, i) if T[j] = k then return j i = i +1 until T[j] = NIL or i = m Return NIL

24

MD5 – PSEUDO CODE: //Note: All variables are unsigned 32 bits and wrap modulo 2^32 when calculating var int[64] r, k //r specifies the per-round shift amounts r[ 0..15] := {7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22} r[16..31] := {5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20} r[32..47] := {4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23} r[48..63] := {6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21} //Use binary integer part of the sines of integers (Radians) as constants: for i from 0 to 63 k[i] := floor(abs(sin(i + 1)) × (2 pow 32)) //Initialize variables: var int h0 := 0x67452301 var int h1 := 0xEFCDAB89 var int h2 := 0x98BADCFE var int h3 := 0x10325476 //Pre-processing: append "1" bit to message append "0" bits until message length in bits ≡ 448 (mod 512) append bit /* bit, not byte */ length of unpadded message as 64-bit little-endian integer to message //Process the message in successive 512-bit chunks: for each 512-bit chunk of message break chunk into sixteen 32-bit little-endian words w[i], 0 ≤ i ≤ 15 //Initialize hash value for this chunk: var int a := h0 var int b := h1 var int c := h2 var int d := h3 //Main loop: for i from 0 to 63 if 0 ≤ i ≤ 15 then f := (b and c) or ((not b) and d) g := i else if 16 ≤ i ≤ 31 f := (d and b) or ((not d) and c) g := (5×i + 1) mod 16 else if 32 ≤ i ≤ 47

25

f := b xor c xor d g := (3×i + 5) mod 16 else if 48 ≤ i ≤ 63 f := c xor (b or (not d)) g := (7×i) mod 16 temp := d d := c c := b b := b + leftrotate((a + f + k[i] + w[g]) , r[i]) a := temp //Add this chunk's hash to result so far: h0 := h0 + a h1 := h1 + b h2 := h2 + c h3 := h3 + d var int digest := h0 append h1 append h2 append h3

Viva questions:

Define hashing.

List the hashing techniques.

How can a data be inserted in to the hash table?

What is hash table?

What are the applications of hashing techniques?

26

IMPLEMENTATION OF BACKTRACKING ALGORITHM FOR KNAPSACK PROBLEM

Ex. No. :8

AIM:- To implement backtracking algorithm for Knapsack problem. ALGORITHM:-

function backtracking (current depth) if solution is valid return / print the solution else for each element from A[] source array let X[current depth] ß element if possible candidate (current depth + 1) backtracking (current depth + 1) end if end for end if end function (OR) Procedure knapsack: Initialize root; PQ <- root; max_cost := root.cost; while PQ not equal do current <- PQ; if (current.bound > max_cost) then create left_child := next item; if (left_child.cost > max_cost) max_cost := left_child.cost; update best_solution; end if; if (left_child.bound > max_cost)

27

PQ <- left_child; end if; create right_child; // it skips packing the next item if (right_child.bound > max_cost) PQ <- right_child; end if; end if; end while; return best_solution and its cost; end procedure;

Viva questions:

Describe knapsack problem.

What is the significance of backtracking algorithm?

28

IMPLEMENTATION OF PRIM'S AND KRUSKAL'S ALGORITHMS

Ex. No. :9

AIM:- To implement prim's and kruskal's algorithms. ALGORITHM:- Prim’s Algorithm:

E(1) is the set of the sides of the minimum genetic tree. E(2) is the set of the remaining sides.

E(1)=0,E(2)=E While E(1) contains less then n-1 sides and E(2)=0 do

From the sides of E(2) choose one with minimum cost-->e(ij) E(2)=E(2)-{e(ij) } If V(i),V(j) do not belong in the same tree then

o unite the trees of V(i) and V(j) to one tree. end (If) end (While)

End Of Algorithm. Kruskal’s Algorithm:

1 function Kruskal(G) 2 for each vertex v in G do 3 Define an elementary cluster C(v) ← {v}.

4 Initialize a priority queue Q to contain all edges in G, using the weights as keys. 5 Define a tree T ← Ø //T will ultimately contain the edges of the MST 6 // n is total number of vertices 7 while T has fewer than n-1 edges do 8 // edge u,v is the minimum weighted route from/to v 9 (u,v) ← Q.removeMin() 10 // prevent cycles in T. add u,v only if T does not already contain a path between u and v.

29

11 // Note that the cluster contains more than one vertex only if an edge containing a pair of 12 // the vertices has been added to the tree. 13 Let C(v) be the cluster containing v, and let C(u) be the cluster containing u. 14 if C(v) ≠ C(u) then 15 Add edge (v,u) to T. 16 Merge C(v) and C(u) into one cluster, that is, union C(v) and C(u). 17 return tree T

Viva questions:

What is prim’s algorithm? Where is it used?

What is the Significance of prim’s algorithm?

30

IMPLEMENTATION OF DIJKSTRA'S ALGORITHM USING PRIORITY QUEUES

Ex. No. :10

AIM:- To implement Dijkstra's algorithm using priority queues. ALGORITHM:-

1. Assign to every node a distance value. Set it to zero for our initial node and to infinity for all other nodes.

2. Mark all nodes as unvisited. Set initial node as current. 3. For current node, consider all its unvisited neighbours and calculate their distance (from the initial

node). For example, if current node (A) has distance of 6, and an edge connecting it with another node (B) is 2, the distance to B through A will be 6+2=8. If this distance is less than the previously recorded distance (infinity in the beginning, zero for the initial node), overwrite the distance.

4. When we are done considering all neighbours of the current node, mark it as visited. A visited node will not be checked ever again; its distance recorded now is final and minimal.

5. Set the unvisited node with the smallest distance (from the initial node) as the next "current node" and continue from step 3 .

1 function Dijkstra(Graph, source):

2 for each vertex v in Graph: // Initializations

3 dist[v] := infinity // Unknown distance function from source to v

4 previous[v] := undefined // Previous node in optimal path from source

5 dist[source] := 0 // Distance from source to source

6 Q := the set of all nodes in Graph

// All nodes in the graph are unoptimized - thus are in Q

7 while Q is not empty: // The main loop

31

8 u := vertex in Q with smallest dist[]

9 if dist[u] = infinity:

10 break // all remaining vertices are inaccessible

11 remove u from Q

12 for each neighbor v of u: // where v has not yet been removed from Q.

13 alt := dist[u] + dist_between(u, v)

14 if alt < dist[v]: // Relax (u,v,a)

15 dist[v] := alt

16 previous[v] := u

17 return previous[]

OUTPUT:

Viva Questions:

What is queue?

You know what a queue is .... Implement a queue class with Java. What is the cost

of enqueue and dequeue? Can you improve this? What if the queue is full (I was

using an looping array)? What kind of mechanism would you use to increase its

size?

Give a good data structure for having n queues ( n not fixed) in a finite memory

segment. You can have some data-structure separate for each queue. Try to use at

least 90% of the memory space.

32

Implementation of array based circular queue

Ex. No. :11

Aim:

To implement array based circular queue and to use the same for solving producer consumer problem

Algorithm:

33

Viva questions:

What is an array?

Write the Significance of array based circular queue.

Write any one application of array based circular queue.

34

IMPLEMENTATION OF PRIORITY QUEUE USING HEAPS

Ex. No. :12

AIM:- To implement priority queue using heaps. ALGORITHM:-

35

function heapSort(a, count) is input: an unordered array a of length count (first place a in max-heap order) heapify(a, count) end := count - 1 while end > 0 do (swap the root(maximum value) of the heap with the last element of the heap) swap(a[end], a[0]) (decrease the size of the heap by one so that the previous max value will stay in its proper placement) end := end - 1 (put the heap back in max-heap order) siftDown(a, 0, end) function heapify(a,count) is (start is assigned the index in a of the last parent node) start := (count - 2) / 2 while start ≥ 0 do (sift down the node at index start to the proper place such that all nodes below the start index are in heap order) siftDown(a, start, count-1) start := start - 1 (after sifting down the root all nodes/elements are in heap order) function siftDown(a, start, end) is input: end represents the limit of how far down the heap to sift. root := start while root * 2 + 1 ≤ end do (While the root has at least one child) child := root * 2 + 1 (root*2+1 points to the left child) (If the child has a sibling and the child's value is less than its sibling's...) if child + 1 ≤ end and a[child] < a[child + 1] then child := child + 1 (... then point to the right child instead) if a[root] < a[child] then (out of max-heap order) swap(a[root], a[child]) root := child (repeat to continue sifting down the child now) else return

Viva questions:

36

What is malloc()?

Define heap data structure.

What is priority queue?

Difference between calloc and malloc?

IMPLEMENTATION OF BRANCH AND BOUND ALGORITHM

Ex. No. :13

AIM:- To implement the BRANCH AND BOUND ALGORITHM ALGORITHM:-

37

Viva questions:

What is traveling sales man problem?

What is the significance of branch and bound algorithm?

IMPLEMENTATION OF RANDOMIZED ALGORITHM (MINIMUM CUT)

Ex. No. :14

AIM:-

38

To implement the randomized algorithm of Minimum Cut. ALGORITHM:-

find_min_cut(undirected graph G) { while there are more than 2 nodes in G do { pick an edge (u,v) at random in G contract the edge, while preserving multi-edges remove all loops } output the remaining edges }

Viva questions:

What is minimum cut method?

What is the Significance of randomized algorithm?

IMPLEMENTATION OF TOPOLOGICAL SORT ON A DIRECTED GRAPH TO DECIDE IF IT IS ACYCLIC

Ex No :15 AIM:- To perform topological sort on a directed graph to decide if it is acyclic.

39

ALGORITHM:-

L ← Empty list that will contain the sorted elements S ← Set of all nodes with no incoming edges while S is non-empty do remove a node n from S insert n into L for each node m with an edge e from n to m do remove edge e from the graph if m has no other incoming edges then insert m into S if graph has edges then output error message (graph has at least one cycle) else output message (proposed topologically sorted order: L)