Professional Documents
Culture Documents
LAB MANUAL
2010-2011
INDEX
I LAB SYLLABUS
II LAB PLAN
Experiments to be performed:
Aim:
To develop skills in design and implementation of data structures and their applications.
LAB PLAN
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
4
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
Directed graph to decide is it
is cyclic
Ex. No : 1(a)
AIM:
ALGORITHM:
b) Find the node containing the element (LOC) and its preceding node (PAR).
d) Adjust the link fields so that PAR points to the next element. ie
LINK [PAR] = LINK [LOC].
Ex. No : 1(b)
AIM:
ALGORITHM:
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
Removing a node is easier, only requiring care with the firstNode and lastNode:
7
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:
AIM:
ALGORITHM:
/*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.*/
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
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
9
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
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);.
10
Ex. No. :3
Date :
AIM:
ALGORITHM:
Viva Questions:
• Write a function and the node data structure to visit all of the nodes in a binary tree.
• 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?
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.
12
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:
• 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?
Ex. No. :5
AIM:
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)
13
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
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
14
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
{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.
Ex. No. :6
AIM:
ALGORITHM:
{
15
/* insert the target into the tree, returning 1 on success or 0 if it
* already existed
*/
treep = &tree->next[next_step];
tree = *treep;
if (tree) return 0;
tree = malloc(sizeof(*tree));
tree->longer = NEITHER;
tree->value = target;
*treep = tree;
avl_rebalance(path_top, target);
return 1;
*/
16
while (path && target != path->value) {
node B, C, D, E;
B = *path_top;
D = B->next[dir];
C = D->next[1-dir];
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 B, F, D, C, E;
B = *path_top;
F = B->next[dir];
D = F->next[1-dir];
C = D->next[1-dir];
Ex. No. :7
AIM:
ALGORITHM:
For insertion:
HASH-INSERT (T, k)
i=0
Repeat j <-- h(k, i)
if Y[j] = NIL
18
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
//Note: All variables are unsigned 32 bits and wrap modulo 2^32 when calculating
var int[64] r, k
//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
//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
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
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?
20
Ex. No. :8
AIM:-
ALGORITHM:-
(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)
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:
Ex. No. :9
AIM:-
ALGORITHM:-
Prim’s Algorithm:
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.
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:
AIM:-
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.
24
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 .
9 if dist[u] = infinity:
11 remove u from Q
12 for each neighbor v of u: // where v has not yet been removed from Q.
15 dist[v] := alt
16 previous[v] := u
17 return previous[]
OUTPUT:
Viva Questions:
• What is queue?
25
• 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.
Aim:
To implement array based circular queue and to use the same for solving producer consumer problem
Algorithm:
26
Viva questions:
• What is an array?
• Write the Significance of array based circular queue.
• Write any one application of array based circular queue.
AIM:-
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)
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:
• What is malloc()?
• Define heap data structure.
• What is priority queue?
• Difference between calloc and malloc?
28
ALGORITHM:-
29
Viva questions:
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:
Ex No :15
AIM:-
ALGORITHM:-