gudlavalleru engineering college seshadri rao...

III B.Tech ADVANCED DATA STRUTURES LAB

P a g e | 1 Department of Computer Science & Engineering GEC

GUDLAVALLERU ENGINEERING COLLEGE Seshadri Rao Knowledge Village, Gudlavalleru

Academic Year: 2013–14, Semester : I

Class: III B.Tech Branch: CSE Subject: Advanced Data Structures Lab

====================================================================

List of experiments:

1. To implement functions of Dictionary using Hashing

(i).Division Method

(ii).Multiplication Method

(iii).Universal Hashing

2. To perform various operations i.e, insertions and deletions on AVL trees

3. To perform various operations i.e., insertions and deletions on 2-3 trees.

4. To implement operations on binary heap.

5. To implement operations on graphs

(i) Vertex insertion

(ii) Vertex deletion

(iii) Finding vertex

(iv) Edge addition and deletion

6. To implement Depth First Search for a graph nonrecursively.

7. To implement Breadth First Search for a graph nonrecursively.

8. To implement Prim’s algorithm to generate a min-cost spanning tree.

9. To implement Krushkal’s algorithm to generate a min-cost spanning tree.

10. To implement Dijkstra’s algorithm to find shortest path in the graph.

11. To implement pattern matching using Boyer-Moore algorithm.

12. To implement Knuth-Morris-Pratt algorithm for pattern matching.



EXERCISE: 1

AIM:

Program to implement functions of Dictionary using Hashing

(i).Division Method

(ii).Multiplication Method

(iii).Universal Hashing

DESCRIPTION:

DICTIONARIES:

A dictionary is a collection of Paris of the form (k,v) where k is a key and v is the value

associated with the key k . No two pairs in a dictionary have the same key.

A Dictionary may be maintained as an ordered linear list and can be represented using skip lists and

hashing.. This method uses a hash function to map dictionary pairs into positions in a table called the

hash table. In the ideal situation, if pair p has the key k and f is the hash function, then p is stored in

position f(k) of the table. Assume for now that each position of the table can store at most one pair.

To search for a pair with key k, we compute f(k) and see whether a pair exists at position f(k) of the

table. If so, we have found the desired pair. If not, the dictionary contains no pair with the specified

key k. in the former case the pair may be deleted by making position f(k) of the table empty. In the

latter case the pair may be inserted by placing it in position f(k).

HASH TABLES: An extremely effective and practical way of implementing dictionaries. O(1) time

for search, insert, and delete in the average case. O(n) time in the worst case; by careful design, we

can make the probability that more than constant time is required to be arbitrarily small.

Types of Hash Tables:

1. Open or External

2. Closed or Internal

Open Hashing:

Let:

1. U be the universe of keys:

integers

character strings

complex bit patterns

2. B the set of hash values (also called the buckets or bins).Let B = {0, 1,..., m - 1}where m > 0 is

a positive integer.

A hash function h: U B associates buckets (hash values) to keys.



Two main issues:

1. Collisions: If x1 and x2 are two different keys, it is possible that h(x1) = h(x2). This is called a

collision. Collision resolution is the most important issue in hash table implementations.

2. Hash Functions: Choosing a hash function that minimizes the number of collisions and also

hashes uniformly is another critical issue.

Collision Resolution by Chaining:

Put all the elements that hash to the same value in a linked list. See the following Figure 1.

Figure 1: Collision resolution by chaining

Example: See the following Figure 2. Consider the keys 0, 1, 4, 9, 16, 25, 36, 49, 64, 81,100.

Let the hash function be:h(x) = x % 7

Figure 2: Open hashing: An example

Bucket lists:

unsorted lists



sorted lists (these are better)

Insert (x, T) : Insert x at the head of list T[h(key (x))]

Search (x, T): Search for an element x in the list T[h(key (x))]

Delete (x, T) : Delete x from the list T[h(key (x))]

Worst case complexity of all these operations is O (n)

In the average case, the running time is O(1 + ), where

= load factor

(1.1)

n = number of elements stored (1.2)

m = number of hash values or buckets

It is assumed that the hash value h(k) can be computed in O(1) time. If n is O(m), the average case

complexity of these operations becomes O(1) !

Closed Hashing:

1. All elements are stored in the hash table itself.

2. Avoids pointers; only computes the sequence of slots to be examined.

3. Collisions are handled by generating a sequence of rehash values.

H: x {0, 1, 2,..., m - 1}

Given a key x, it has a hash value h(x,0) and a set of rehash valuesh(x, 1), h(x,2), . . . , h(x, m-1)

We require that for every key x, the probe sequence< h(x,0), h(x, 1), h(x,2), . . . , h(x, m-1)> be a

permutation of <0, 1, ..., m-1>.

This ensures that every hash table position is eventually considered as a slot for storing a record with

a key value x.

1. Search (x, T): Search will continue until you find the element x (successful search) or an

empty slot (unsuccessful search).

2. Delete (x, T): No delete if the search is unsuccessful.If the search is successful, then put the

label DELETED (different from an empty slot).

3. Insert (x, T): No need to insert if the search is successful.If the search is unsuccessful, insert

at the first position with a DELETED tag.

Rehashing Methods:

Denote h(x, 0) by simply h(x).

Linear probing : h(x, i) = (h(x) + i) mod m

Quadratic Probing : h(x, i) = (h(x) + C1i + C2i2) mod mWhere C1 and C2 are constants

Double Hashing: h(x, i) = (h(x) + i h’(x)) mod m

A Comparison of Rehashing Methods



m distinct probe

sequences

Primary clustering

m distinct probe

sequences

No primary clustering;

but secondary clustering

m2 distinct probe

sequences

No primary clustering

No secondary clustering

An Example:Assume linear probing with the following hashing and rehashing functions:

h(x, 0) = x%7

h(x, i) = (h(x, 0) + i)%7

Start with an empty table.

Search (35, T) 0 14

Delete (9, T) 1 empty

2 30

3 deleted

4 45

5 empty

6 20

Insert (20, T) 0 14

Insert (30, T) 1 empty

Insert (9, T) 2 30

Insert (45, T) 3 9

Insert (14, T) 4 45

5 empty

6 20

Delete (45, T) 0 14

Insert (16, T) 1 empty

2 30

3 10

4 16

5 empty

6 20

Search (45, T) 0 14

Search (52, T) 1 empty

Search (9, T) 2 30

Insert (45, T) 3 10

Insert (10, T) 4 45

5 empty

6 20



Program:

#include<stdio.h>

#include<conio.h>

int htable[20],h,op,key,m,i,pos,count=0,flag;

void main()

{

clrscr();

printf("\nEnter Hash Table Size:");

scanf("%d",&m);

printf("-------------HASH FUNCTIONS--------------");

printf("\n[1].Division\n[2].Multiplication\n[3].Universal");

printf("\nChoose Hash Function:");

scanf("%d",&h);

do

{

printf("--------------OPERATIONS ON DICTIONARIES--------------\n");

printf("\t[1].INSERT\n\t[2].DELETE\n\t[3].SEARCH\n\t[4].DISPLAY\n\t[0].EXIT");

printf("\nEnter Operation:");

scanf("%d",&op);

switch(op)

{

case 1: if(count<m)/* checking if the Hash table is already FULL */

{



generatepos();/* finding location using h(k) */

insert();

}

else printf("\nHash Table is Full");

break;

case 2: if(count==0)/* checking if the Hash table is EMPTY */

printf("\nHash Table is Empty");

else

{

generatepos();

delete();

}

break;

case 3: if(count==0)


else

{

generatepos();

if(search(key)==-1)/* If search is unsuccessful */

printf("\nKey Not Found in the Hash Table");

else

printf("\nKey Found At Location:%d",search(key));

}

break;



case 4: if(count==0)


else

display();

break;

}

}while(op!=0);

}

generatepos()

{

printf("Enter Key:");

scanf("%d",&key);

if(h==1)

pos=division(key);

else if(h==2)

pos=multiply(key);

else

pos=universal(key);

}

int division(int k)

{

return (k%m); /* hash function h(k)=(k%m) */



}

int multiply(int k)

{

/* hash function h(k)=floor(m*(kA-|kA|)) */

float a=0.61804,t2;

int t1;

t1=(k*a); /* |kA| */

t2=(k*a); /* kA */

t2=t2-t1; /* kA - |kA| */

pos=t2*m;

return pos;

}

int universal(int k)

{

/* hash function h(k)=(a*k+b)%p)%m); a,b, p are prime numbers where a,b<m and p>=m */

/* a and b constant primes < m */

/* p is prime > m */

int p=13,a=7,b=5;

pos=((a*k+b)%p)%m;

return pos;

}

insert()

{

flag=0;



if(search(key)==-1) /* If search is Unsuccessful */

{

/* searching circularly until an empty location is found */

while(flag==0)

{

if(htable[pos]==0)/* if location is empty */

{

htable[pos]=key; /* Inserting key */

printf("\nKey Inserted at Location: %d",pos);

count++;

flag=1;

break;

}

else /* Collision */

{

printf("\nCollision Occured at Location:%d",pos);

pos=(pos+1)%m; /* Linear probing */

}

}

}

else printf("\nKey is already present in the Hash Table");

}

delete()

{



flag=0;

if(search(key)!=-1)/* If search is Successful */

{

while(flag==0)/* searching for the key circularly */

{

if(htable[pos]==key)/* Key found */

{

htable[pos]=0; /* deleting key */

printf("\nKey Deleted from Location: %d",pos);

count--;

flag=1;

break;

}

else

pos=(pos+1)%m; /* linear probing */

}

}

else printf("\nKey Not Found in the Hash Table");

}

int search(int k)

{

for(i=0;i<m;i++)

{

if(htable[i]==k)



return i;

}

return -1;

}

display()

{

printf("\nElements in the Hash Table are:\n");

for(i=0;i<m;i++)

printf("%d\t",htable[i]);

}

Output:

(1).

Enter Hash Table Size:10

-------------HASH FUNCTIONS--------------

[1].Division

[2].Multiplication

[3].Universal

Choose Hash Function:1

--------------OPERATIONS ON DICTIONARIES--------------

[1].INSERT

[2].DELETE

[3].SEARCH

[4].DISPLAY

[0].EXIT



Enter Operation:1

Enter Key:123

Key Inserted at Location: 3

Enter Operation:1

Enter Key:133

Collision Occured at Location:3


Enter Operation:1

Enter Key:234



Enter Operation:4

Elements in the Hash Table are:

0 0 0 123 133 234 0 0 0 0

Enter Operation:1

Enter Key:222


Enter Operation:1

Enter Key:232








Enter Operation:4


0 0 222 123 133 234 232 0 0 0

Enter Operation:2

Enter Key:111

Key Not Found in the Hash Table

Enter Operation:2

Enter Key:232

Key Deleted from Location: 6

Enter Operation:2

Enter Key:222


Enter Operation:3

Enter Key:222


Enter Operation:2

Enter Key:222




Enter Operation:0

(2) Enter Hash Table Size:5

-------------HASH FUNCTIONS--------------

[1].Division

[2].Multiplication

[3].Universal

Choose Hash Function:2

--------------OPERATIONS ON DICTIONARIES--------------

[1].INSERT

[2].DELETE

[3].SEARCH

[4].DISPLAY

[0].EXIT

Enter Operation:1

Enter Key:22


Enter Operation:1

Enter Key:23


Enter Operation:2

Enter Key:34


Enter Operation:2

Enter Key:23


Enter Operation:4


0 0 22 0 0

Enter Operation:1

Enter Key:44


Enter Operation:1

Enter Key:24


Enter Operation:4




44 0 22 0 24

Enter Operation:0

EXERCISE: 2 AIM:

Implementation of a C program to perform various operations i.e., insertions and deletions on

AVL trees.

Description: AVL Trees: Also called as: Height Balanced Binary Search Trees. Search, Insertion, and

Deletion can be implemented in worst case O (log n) time.

Definition: An AVL tree is a binary search tree in which

1. The heights of the right subtree and left subtree of the root differ by at most 1

2. The left subtree and the right subtree are themselves AVL trees

3. A node is said to be

left-high if the left subtree has

greater height /

right-high if the right subtree has

greater height

equal if the heights of the LST and

RST are the same -

Examples: Several examples of AVL trees are shown in

Figure1.

PROGRAM :

#include<stdio.h>

#include<conio.h>



struct avl

{

struct avl *lchild,*rchild;

int data,h;

};

#define max(a,b) (a>b?a:b)

int count=0;

int height(struct avl *root)

{

if(root==NULL)

return -1;

else

return root->h;

}

int isEmpty(struct avl *p)

{

return(p==NULL && count==0);

}

struct avl *findMin(struct avl *p)

{

if(p == NULL) return NULL;

else

{

if(p->lchild==NULL) return p;



else return findMin(p->lchild);

}

}

struct avl *search( struct avl *p,int x)

{

struct avl *t;

t = p;

while( t != NULL)

{

if(t->data == x)

return(t);

else if(t->data > x)

t = t->lchild;

else

t = t->rchild;

}

return(NULL);

}

struct avl *rotateRight(struct avl *root)

{

struct avl *t;

t=root->lchild;

root->lchild=t->rchild;



t->rchild=root;

root->h=max(height(root->lchild),height(root->rchild))+1;

t->h=max(height(t->lchild),height(t->rchild))+1;

return t;

}

struct avl *rotateLeft(struct avl *root)

{

struct avl *t;

t=root->rchild;

root->rchild=t->lchild;

t->lchild=root;


t->h=max(height(t->lchild),height(t->rchild))+1;

return t;

}

struct avl *RightBal(struct avl *root)

{

struct avl *t;

if(height(root->rchild)-height(root->lchild)==2)

{

t=root->rchild;

if((t->rchild->data>t->data) && (t->rchild!=NULL))

{

printf("\n\n\tRR(single left) Rotation");



root=rotateLeft(root);

}

else

{

printf("\n\n\tRL Rotation");

root->rchild=rotateRight(t);

root=rotateLeft(root);

}

}

return root;

}

struct avl *LeftBal(struct avl *root)

{

struct avl *t;

if(height(root->lchild)-height(root->rchild)==2)

{

t=root->lchild;

if((t->lchild->data<t->data) && (t->lchild!=NULL))

{

printf("\n\n\tLL(single right) Rotation");

root=rotateRight(root);

}

else

{



printf("\n\n\tLR Rotation");

root->lchild=rotateLeft(t);

root=rotateRight(root);

}

}

return root;

}

struct avl *insert(int x,struct avl *root)

{

if(root==NULL)

{

root=(struct avl *)malloc(sizeof(struct avl));

root->data=x;

root->h=0;

count++;

root->lchild=root->rchild=NULL;

printf("\n\tNode Inserted");

}

else if(x<root->data)

{

root->lchild=insert(x,root->lchild);

root=LeftBal(root);

}

else if(x>root->data)



{

root->rchild=insert(x,root->rchild);

root=RightBal(root);

}


return root;

}

struct avl *delete(int x,struct avl *p)

{

struct avl *temp;

if(x<p->data)

{

p->lchild = delete(x,p->lchild);

p=RightBal(p);

}

else if(x>p->data)

{

p->rchild = delete(x,p->rchild);

p=LeftBal(p);

}

else if(p->lchild && p->rchild)

{

temp = findMin(p->rchild);



p->data = temp->data;

p->rchild = delete(p->data,p->rchild);

p=LeftBal(p);

}

else

{

temp = p;

if(p->lchild==NULL) p=p->rchild;

else if(p->rchild==NULL) p=p->lchild;

free(temp);

printf("\n\tNode Deleted");

p->h=max(height(p->lchild),height(p->rchild))+1;

count--;

}

return p;

}

void inorder(struct avl *p)

{

if(p!=NULL)

{

inorder(p->lchild);

printf("%4d",p->data);

inorder(p->rchild);



}

}

void main()

{

struct avl *root=NULL;

struct avl *t=NULL;

int ch,x;

clrscr();

printf("\t\t----------------LIST OF OPERATIONS------------------");

printf("\n\t\t\t[1].INSERT");

printf("\n\t\t\t[2].TRAVERSAL");

printf("\n\t\t\t[3].DELETE");

printf("\n\t\t\t[0].EXIT");

do

{

printf("\n\n\tEnter Choice Of Operation:");

scanf("%d",&ch);

switch(ch)

{

case 1: printf("\n\tEnter Value:");

scanf("%d",&x);

if(search(root,x)==NULL)

root=insert(x,root);



else

printf("\n\tElement already present");

break;

case 2:if(!isEmpty(root))

{

printf("\n\tInorder Traversal:\t");

inorder(root);

}

else printf("\n\tAVL Tree Is Empty\n");

break;

case 3:if(!isEmpty(root))

{

printf("\n\tEnter Node To Be Deleted:");

scanf("%d",&x);

if(search(root,x)!=NULL)

root=delete(x,root);

else

printf("\n\tElement Not Found");

}

else printf("\n\tAVL Tree Is Empty\n");

break;

default:

if(ch!=0) printf("\n\tInvalid Choice Of Operation");

}



}while(ch!=0);

getch();

}

OUTPUT:

(1). ----------------LIST OF OPERATIONS------------------

[1].INSERT

[2].TRAVERSAL

[3].DELETE

[0].EXIT

Enter Choice Of Operation:1

Enter Value:12

Node Inserted


Enter Value:24

Node Inserted


Enter Value:20

RL Rotation


Enter Value:3

Node Inserted


Invalid Choice Of Operation




Inorder Traversal: 3 12 20 24


Enter Value:8

Node Inserted

LR Rotation


Inorder Traversal: 3 8 12 20 24


Enter Value:39

Node Inserted


Enter Value:78

Node Inserted

RR(Single left) Rotation


Inorder Traversal: 3 8 12 20 24 39 78


EXERCISE: 3

AIM:

Write a C program to perform various operations on 2-3 trees.

DESCRIPTION:

Definition: A 2-3 Tree is a null tree (zero nodes) or a single node tree (only one node) or a multiple

node tree with the following properties:

Each interior node has two or three children

Each path from the root to a leaf has the same length.

Fields of a Node:

Internal Node:

p1 k1 p2 k2 p3

p1:Pointer to the first child

p2:Pointer to the second child



p3:Pointer to the third child

k1:Smallest key that is a descendent of the second child

k2:Smallest key that is a descendent of the third child

Leaf Node:

key other fields

Note: Records are placed at the leaves. Each leaf contains a record (and key)

Example: See Figure1

Search: The values recorded at the internal nodes can be used to guide the search path.

To search for a record with key value x, we first start at the root. Let k1 and k2 be the two

values stored here.

1. If x < k1, move to the first child

2. If x >=k1 and the node has only two children, move to the second child

3. If x >=k1 and the node has three children, move to the second child if x < k2 and to the

third child if x >=k2.

Eventually, we reach a leaf. x is in the tree iff x is at this leaf.

Path Lengths:

A 2-3 Tree with k levels has between 2k - 1

and 3k - 1

leaves

Thus a 2-3 tree with n elements (leaves) requires

i. at least 1 + log3n levels

ii. at most 1 + log2n levels

ALGORITHM FOR INSERTIONS INTO 2-3 TREES: Insert (x):

1. Locate the node v, which should be the parent of x

2. If v has two children,

Figure 1: An example of a 2-3 tree



make x another child of v and place it in the proper order

adjust k1 and k2 at node v to reflect the new situation

3. If v has three children,

split v into two nodes v and v'. Make the two smallest among four children stay

with v and assign the other two as children of v'.

Recursively insert v' among the children of w where

w = parent of v

The recursive insertion can proceed all the way up to the root, making it necessary to

split the root. In this case, create a new root, thus increasing the number of levels by 1.

ALGORITHM FOR DELETIONS INTO 2-3 TREES:

Delete (x)

Locate the leaf L containing x and let v be the parent of L

Delete L. This may leave v with only one child. If v is the root, delete v and let its lone child

become the new root. This reduces the number of levels by 1. If v is not the root, let p =

parent of v, If p has a child with 3 children, transfer an appropriate one to v if this child is

adjacent (sibling) to v.

If children of p adjacent to v have only two children, transfer the lone child of v to an adjacent

sibling of v and delete v.

If p now has only one child, repeat recursively with p in place of v. The recursion can ripple

all the way up to the root, leading to a decrease in the number of levels.

Figure 2: Insertion in 2-3 trees: An example



PROGRAM:

/*2-3 TREE*/

#include<stdio.h>

#include<conio.h>

#define c 2

struct node

{

int data[c];

struct node *add[c+1];

}*root,*p,*l,*n,*n1;

int q[4],ele,i,j;

main()

Figure 3: Deletion in 2-3 trees: An Example



{

int ch;

root=NULL;

clrscr();

while(1)

{

printf("\n1.insert \t2.display\t3.exit");

ptintf(“\n enter your choice: “);

scanf("%d",&ch);

switch(ch)

{

case 1: printf("\nenter the value to be inserted: ");

scanf("%d",&ele);

p=n1=NULL;

insert();

break;

case 2: printf(“\nElements are :”);

display(root);

printf("\n");

break;

case 3:exit();

default:printf("wrong choice…\n");

}

}

getch();

}

insert()

{

int temp;

printf("enter the element\n");

scanf("%d",&ele);

if(root==NULL)

{

n=(struct node *)malloc(sizeof(struct node));

n->data[0]=ele;

for(i=0;i<=c;i++)

n->add[i]=NULL;

n->data[1]=NULL;

root=n;

}

else

{

if(Search(p))

{

if(Is2Node(p))

{

p->data[1]=p->data[0];



if(ele<p->data[0])

p->data[0]=ele;

else

p->data[1]=ele;

p->add[1]=n1;

}

else

{

Split();

}

}

else

{


n->data[0]=ele;

n->data[1]=n->add[2]=NULL:

n->add[0]=p;

n->add[1]=n1;

root=n;

}

}

}

int Search(struct node *t)

{

l=root;

while(l!=t)

{

p=l;

for(i=0;i<c;i++)

{

if(l->data[i]!=NULL)

{

if(ele<l->data[i])

{

l=l->add[i];

break;

}

else if(i==1||l->data[i+1]==NULL)

{

l=l->add[i+1];

break;

}

}

}

}

if(p!=t)



return 0;

else

return 1;

}

int Is2Node(struct node *t)

{

for(i=0;i<c;i++)

if(t->data[i]==NULL)

return 0;

return 1;

}

Split()

{

int a,b,c;

a=Min(ele,p->data[0],p->data[1]);

b=Mid(ele,p->data[0],p->data[1]);

c=Max(ele,p->data[0],p->data[1]);


n->add[0]=p->add[2];

n->add[1]=n1;

n->add[2]=p->add[2]=NULL;

n->data[1]=p->data[1]=NULL;

p->data[0]=a;

n->data[0]=c;

n1=n;

ele=b;

insert();

}

int Min(int a,int b,int c)

{

if(a<b&&a<c)

return a;

else if(b<a&&b<c)

return b;

else

return c;

}

int Mid(int a,int b,int c)

{

if(a<b&&a>c||a>b&&a<c)

return a;

else if(b<a&&b>c||b>a&&b<c)

return b;

else

return c;

}

int Max(int a,int b,int c)



{

if(a>b&&a>c)

return a;

else if(b>a&&b>c)

return b;

else

return c;

}

display(struct node *t)

{

if(t!=NULL)

{

display(t->add[0]);

printf("%d\t",t->data[0]);

display(t->add[1]);

if(t->data[1]!=NULL)

{

printf("%d\t",t->data[1]);

display(t->add[2]);

}

}

}

OUTPUT: 1.insert 2.display 3.exit

enter your choice: 1

enter the value to be inserted: 7

1.insert 2.display 3.exit



















Elements are : 5 7 8 12 16 19



wrong choice...



EXERCISE: 4

AIM:

To Write a C program to perform various operations on Binary Heap.

DESCRIPTION:

Binary Heaps:

Heaps (occasionally called as partially ordered trees) are a very popular data structure for

implementing priority queues.

A heap is either a min-heap or a max-heap. A min-heap supports the insert and delete-min

operations while a max-heap supports the insert and delete-max operations.

Heaps could be binary or d-ary. Binary heaps are special forms of binary trees while d-ary

heaps are a special class of general trees.

Definition: A binary heap is a complete binary tree with elements from a partially ordered set, such

that the element at every node is less than (or equal to) the element at its left child and the element at

its right child. Figure 1 shows and example of a heap.

Figure 1: An example of a heap and its array representation



Since a heap is a complete binary tree, the elements can be conveniently stored in an array. If

an element is at position i in the array, then the left child will be in position 2i and the right

child will be in position 2i + 1. By the same token, a non-root element at position i will have

its parent at position [i/2].

Because of its structure, a heap with height k will have between 2kand 2

k + 1 - 1 elements.

Therefore a heap with n elements will have height = [log2n].

Because of the heap property, the minimum element will always be present at the root of the

heap. Thus the find min operation will have worst-case O (1) running time.

ALGORITHM FOR INSERTIONS INTO MIN-HEAP:

Insert: To insert an element say x, into the heap with n elements, we first create a hole in position

(n+1) and see if the heap property is violated by putting x into the hole. If the heap property is not

violated, then we have found the correct position for x. Otherwise, we ``push-up'' or ``percolate-up'' x

until the heap property is restored. To do this, we slide the element that is in the hole's parent node

into the hole, thus bubbling the hole up toward the root. We continue this process until x can be

placed in the whole. See Figure 2 for an example.

Figure 2: Insertion into a heap



Worst case complexity of insert is O (h) where h is the height of the heap. Thus insertions are O (log

n) where n is the number of elements in the heap.

ALGORITHM FOR DELETIONS INTO MIN-HEAP:

When the minimum is deleted, a hole is created at the root level. Since the heap now has one less

element and the heap is a complete binary tree, the element in the least position is to be relocated.

This we first do by placing the last element in the hole created at the root. This will leave the heap

property possibly violated at the root level. We now ``push-down'' or ``percolate-down'' the hole at

the root until the violation of heap property is stopped. While pushing down the hole, it is important

to slide it down to the less of its two children (pushing up the latter). This is done so as not to create

another violation of heap property. See Figure 3. It is easy to see that the worst-case running time

of delete-min is O (log n) where n is the number of elements in the heap.

Figure 3: Deletemin



ALGORITHM FOR CREATING HEAP:

Given a set of n elements, the problem here is to create a heap of these elements.

Obvious approach is to insert the n elements, one at a time, into an initially empty heap. Since

the worst case complexity of inserts is O (log n), this approach has a worst case running time

of O ( n log n)

Another approach, purposed by Floyd in 1964, is to use a procedure called ``pushdown''

repeatedly, starting with the array consisting of the given n elements in the input-order.

o The function pushdown (first, last) assumes that the elements a[first], ..., a[last] obey

the heap property, except possibly the children of a[first]. The function pushes down

a[first] until the heap property violation is stopped.

o The following code will accomplish what is required:

For (i=n/2;i>=1;i++)

Pushdown(I,n);

Figure 4 shows an example of this for an array [5 9 4 2 1 6]. The worst case complexity of this

approach can be shown to b O (n) by virtue of the following result.

Figure 4: Creation of heap



Algorithm:

1.

PROGRAM:

#include<stdio.h>

#include<conio.h>

int ch,i,heap[50],n,k,left,right,target,temp,parent;

void main()

{

clrscr();

printf("\n---------------HEAP OPERATIONS------------------");

printf("\n[1].BUILD_HEAP\n[2].INSERT\n[3].DELETEMIN\n[4].DISPLAY\n[0].EXIT");

do

{

printf("\nChoose Operation:");

scanf("%d",&ch);

switch(ch)

{

case 1: build_heap();

display();

break;

case 2: insert();

break;

case 3: deletemin();

break;

case 4: display();

break;

}

}while(ch!=0);

}

build_heap()



{

printf("\nEnter No of Elements in Heap:");

scanf("%d",&n);

printf("\nEnter %d elements:\n",n);

for(i=1;i<=n;i++)

scanf("%d",&heap[i]);

for(i=n/2;i>0;i--)

percolate_down(i);

}

insert()

{

printf("Enter Element:");

scanf("%d",&temp);

n++;

heap[n]=temp;

printf("\nElement Inserted");

percolate_up(n);

}

deletemin()

{

if(n>0)

{

printf("\nElement Deleted Is:%d",heap[1]);

heap[1]=heap[n];

heap[n]=0;

n--;

percolate_down(1);

}

else printf("\nHeap Is Empty");

}

display()

{



if(n>0)

{

printf("\nThe Min-Heap is:\n");

i=1;

while(i<=n)

{

for(k=i;k<(2*i) && k<=n;k++)

printf("%d ",heap[k]);

printf("\n");

i=k;

}

}

else printf("\nHeap is Empty");

}

percolate_up(int m)

{

while(m>1)

{

parent=m/2;

if(heap[parent] > heap[m])

{

temp=heap[m];

heap[m]=heap[parent];

heap[parent]=temp;

m=parent;

}

else break;

}

}

percolate_down(int m)

{

while(2*m <= n)



{

left=2*m;

right=2*m+1;

if(right <=n && heap[right] < heap[left])

target=right;

else

target=left;

if(heap[target] < heap[m])

{

temp=heap[m];

heap[m]=heap[target];

heap[target]=temp;

m=target;

}

else break;

}

}

OUTPUT:

(1).

---------------HEAP OPERATIONS------------------

[1].BUILD_HEAP

[2].INSERT

[3].DELETEMIN

[4].DISPLAY

[0].EXIT

Choose Operation:1

Enter No of Elements in Heap:5

Enter 5 elements:

12

34



5

6

89

The Min-Heap is:

5

6 12

34 89

Choose Operation:2

Enter Element:4

Element Inserted

Choose Operation:4

The Min-Heap is:

4

6 5

34 89 12

Choose Operation:2

Enter Element:7

Element Inserted

Choose Operation:4

The Min-Heap is:

4

6 5

34 89 12 7

34 89 12 7



Choose Operation:3

Element Deleted Is:4

Choose Operation:4

The Min-Heap is:

5

6 7

34 89 12

Choose Operation:3

Element Deleted Is:5

Choose Operation:4

The Min-Heap is:

6

12 7

Choose Operation:0

EXERCISE: 5

AIM:

Write a C program to implement operations on graphs

Vertex insertion

Vertex deletion

Edge addition

Edge deletion

Find vertex

DESCRIPTION:

1. A graph can be thought of a collection of vertices (V) and edges (E), so we write, G = (V, E)

2. Graphs can be directed, or undirected, weighted or unweighted.



3. A directed graph, or digraph, is a graph where the edge set is an ordered pair. That is, edge 1

being connected to edge 2 does not imply that edge 2 is connected to edge 1. (i.e. it has

direction – trees are special kinds of directed graphs)

4. An undirected graph is a graph where the edge set in an unordered pair. That is, edge 1 being

connected to edge 2 does imply that edge 2 is connected to edge 1.

5. A weighted graph is graph which has a value associated with each edge. This can be a

distance, or cost, or some other numeric value associated with the edge.

ALGORITHM :

(i) VertexInsertion() { If(find(v)==-1) { Ver[n++]=v; Vetex inserted. } }

(ii) DeleteVertex() { i=n-1; v=ver[i]; ver[i]=0; // vertex deleted for(j=0;j<n;j++) { adj[i][j]=adj[j][i]=0; // deletion of edges from that vertex } n--; }

(iii) Add Edge() { If(s!=d && find(s)!=-1 && find(d)!=-1) { i=find(s); j=find(d); if(adj[i][j]==1) printf “already connected”;



else adj[i][j]=1; print “edge connected”; } Print “edge connection not possible”; }

(iv) DeleteEdge() {

If(s!=d && find(s)!=-1 && find(d)!=-1) { i=find(s); j=find(d); if(adj[i][j]==1) { adj[i][j]=0; print “edge deleted”; } else Print “edge not connected”;

} (v) FindVertex(char v)

{ for(int k=0;k<n;k++) { if(ver[k]==v) return k; // vertex found at index k else return -1; }

PROGRAM:

#include<stdio.h>

#include<conio.h>

int n,i,j,ad[10][10];

char ver[20];

display()



{

printf("\nVERTEX\tADJACENT VERTICES\n");

printf("------------------------------------------------\n");

for(i=0;i<n;i++)

{

printf("%c\t",ver[i]);

for(j=0;j<n;j++)

{

if(ad[i][j]!=0)

printf("-->%c",ver[j]);

}

printf("\n");

}

}

int find(char v)

{

int k;

for(k=0;k<n;k++)

{

if(ver[k]==v)

return k;

}

return -1;

}

main()

{

char s,d,v;

int op;

n=0;

clrscr();

do

{



printf("\n---------------------OPERATIONS-----------------------\n");

printf("[1].INSERT VERTEX\n[2].DELETE VERTEX\n[3].ADD AN EDGE\n

[4].DELETE AN EDGE\n[5].FIND VERTEX\n[6].DISPLAY\n[0].EXIT");

printf("\n\nChoose an Operation:");

scanf("%d",&op);

switch(op)

{

case 1:printf("\nEnter Vertex:");

fflush(stdin);

scanf("%c",&v);

if(find(v)!=-1)

printf("\nVERTEX already exists");

else

{

ver[n++]=v;

printf("\nVERTEX INSERTED");

}

break;

case 2:if(n==0) printf("\nGRAPH IS EMPTY");

else

{

i=n-1;

v=ver[n-1];

for(j=0;j<n;j++)

{

ver[i]=0;

ad[i][j]=ad[j][i]=0;

}

n--;

printf("\nVERTEX DELETED Is :%c",v);

}

break;




else

{

printf("\nEnter Source Vertex:");

fflush(stdin);

scanf("%c",&s);

printf("\nEnter Destination Vertex:");

fflush(stdin);

scanf("%c",&d);

if(s!=d && find(s)!=-1 && find(d)!=-1)

{

i=find(s);

j=find(d);

if(ad[i][j]==0)

{

ad[i][j]=1;

printf("\nEDGE INSERTED\n");

}

else printf("\nAlready they are connected by an EDGE");

}

else printf("\nEDGE Is Not Connected\n");

}

break;


else

{

printf("\nEnter Source Vertex:");

fflush(stdin);

scanf("%c",&s);

printf("\nEnter Destination Vertex:");

fflush(stdin);

scanf("%c",&d);



i=find(s);

j=find(d);

if(ad[i][j]!=1)

printf("\nThere is No edge Connecting them");

else

{

ad[i][j]=0;

printf("\nEDGE DELETED\n");

}

}

break;


else

{

printf("\nEnter Vertex:");

fflush(stdin);

scanf("%c",&v);

if(find(v)!=-1)

printf("\nVERTEX FOUND");

else

printf("\nVERTEX NOT FOUND");

}

break;


else display();

break;

}

}while(op!=0);

}

OUTPUT:

---------------------OPERATIONS-----------------------



[1].INSERT VERTEX

[2].DELETE VERTEX

[3].ADD AN EDGE

[4].DELETE AN EDGE

[5].FIND VERTEX

[6].DISPLAY

[0].EXIT

Choose an Operation:1

Enter Vertex: A

VERTEX INSERTED


Enter Vertex:B

VERTEX INSERTED


Enter Vertex:C

VERTEX INSERTED


Enter Source Vertex:A

Enter Destination Vertex:B

EDGE INSERTED


Enter Source Vertex:B

Enter Destination Vertex:C

EDGE INSERTED


Enter Source Vertex:C

Enter Destination Vertex:B



There is No edge Connecting them


VERTEX ADJACENT VERTICES

------------------------------------------------

A -->B

B -->C

C


Enter Source Vertex: A


EDGE INSERTED



------------------------------------------------

A -->B-->C

B -->C

C


Enter Source Vertex:A


EDGE DELETED



------------------------------------------------

A -->B

B -->C



C


VERTEX DELETED Is :C


Enter Vertex:E

VERTEX NOT FOUND


Enter Vertex:B

VERTEX FOUND


EXERCISE: 6

AIM:

Write a C program to implement Depth First Search for a graph non recursively.

DESCRIPTION:

1. A graph can be thought of a collection of vertices (V) and edges (E), so we write, G = (V, E)


3. A directed graph, or digraph, is a graph where the edge set is an ordered pair. That is, edge 1

being connected to edge 2 does not imply that edge 2 is connected to edge 1. (i.e. it has

direction – trees are special kinds of directed graphs).

4. An undirected graph is a graph where the edge set in an unordered pair. That is, edge 1 being

connected to edge 2 does imply that edge 2 is connected to edge 1.



ALGORITHM FOR DEPTH FIRST SEARCH AND TRAVERSAL:

A depth first search of a graph differs from a breadth first search in that the exploration of a

vertex v is suspended as soon as a new vertex is reached. At this time of exploration of the new

vertex u begins. When this new vertex has been explored, the exploration of v continues. The search

terminates when all reached vertices have been fully explored. The search process is best described

recursively in the following algorithm.



Algorithm DFS(v)

{

// Given an undirected(directed) graph G=(V,E) with n vertices and an

//array visited [] initially set to zero, this algorithm visits all vertices reachable

//from v. G and visited[] are global.

if(V==NULL)

print “graph empty”

else

{

while(stack is not empty)

{

V1=pop(v);

if(visited[V1]==false) /*if V1 has not yet visited*/

visited[V1]=true; /* visit V1*/

for(each w adjacent to V1)

{

if(visited[w]==false && inStack(w)==0)

push(w);

}

}//while

}//else

}

PROGRAM:

#include<stdio.h>

#include<conio.h>

int am[10][10],n,v,visited[10],stk[10];

int i,j,top=-1;

void main()

{

clrscr();

printf("Enter Number of Vertices:");

scanf("%d",&n);

printf("\nEnter Adjacency Matrix:");

for(i=1;i<=n;i++)

{

for(j=1;j<=n;j++)

scanf("%d",&am[i][j]);

visited[i]=0;

}

printf("Enter Starting Node:");

scanf("%d",&v);

dfs(v);

}



dfs(int st)

{

top++;

stk[top]=st;

while(top>=0)

{

v=stk[top];

top--;

if(visited[v]==0)

{

visited[v]=1;

printf("-->%d",v);

}

for(i=n;i>=1;i--)

{

if(am[v][i]==1 && visited[i]==0)

{

if(instack(i)==0)

{

top++;

stk[top]=i;

}

}

}

}

}

int instack(int n)

{

for(j=0;j<=top;j++)

{

if(stk[j]==n)

return 1;

}

return 0;

}

OUTPUT:

Enter Number of Vertices:5

Enter Adjacency Matrix:

0 1 1 0 0

1 0 1 1 0

1 1 0 0 0

0 1 0 0 1

0 0 0 1 0



Enter Starting Node:1

-->1-->2-->4-->5-->3

EXERCISE: 7

AIM:

Write a C program to implement Breadth First Search for a graph non recursively.

DESCRIPTION:

1. A graph can be thought of a collection of vertices(V) and edges(E), so we write, G = (V, E)


3. A directed graph, or digraph, is a graph where the edge set is an ordered pair. That is, edge

1 being connected to edge 2 does not imply that edge 2 is connected to edge 1. (i.e. it has

direction – trees are special kinds of directed graphs).

4. An undirected graph is a graph where the edge set in an unordered pair. That is, edge 1

being connected to edge 2 does imply that edge 2 is connected to edge 1.



ALGORITHM FOR BREADTH FIRST SEARCH AND TRAVERSAL:

In Breadth first search we start at vertex v and mark it as having been reached (visited) the

vertex v is at this time said to be unexplored. A vertex is said to have been explored by an algorithm

when the algorithm has visited all vertices adjacent from it. All unvisited vertices adjacent from v are

visited next. These are new unexplored vertices. Vertex v has now been explored. The newly visited

vertices have not been explored and or put on to the end of a list of unexplored list of vertices. The

first vertex on this list is the next to be explored. Exploration continues until no unexplored vertex is

left. The list of unexplored vertices operates as a queue and can be represented using any of the

standard queue representations.

Algorithm BFS(v)

{

//A breadth first search of G is carried out beginning at vertex v. For

//any node v, visited[v]=1 if I has already been visited. The graph G

//and array visited are global; visited[] is initialized to zero.



If(v==NULL)

Print “Graph Empty”;

end if.

else

{

enque(v)

while(queue is not empty)

{

V1=dequeue;

If(visited[v1]==false)

visited[v1]=true;

for(each w adjacent to v1)

{

If(visited[w]==false && inqueue(w)==0)

enqueue(w);

}

}//while

}

}

PROGRAM:

#include<stdio.h>

#include<conio.h>

int am[10][10],n,v,visited[10],q[20],i,j,front=0,rear=0;

void main()

{

clrscr();

printf("Enter Number of Vertices:");

scanf("%d",&n);

printf("\nEnter Adjacency Matrix:");

for(i=1;i<=n;i++)

{

for(j=1;j<=n;j++)

scanf("%d",&am[i][j]);

visited[i]=0;

}

printf("Enter Starting Node:");



scanf("%d",&v);

bfs(v);

getch();

}

bfs(int st)

{

q[rear]=st;

rear++;

while(front<rear)

{

v=q[front];

front++;

if(visited[v]==0)

{

visited[v]=1;

printf("-->%d",v);

}

for(i=1;i<=n;i++)

{

if(am[v][i]==1 && visited[i]==0)

{

if(inqueue(i)==0)

{

q[rear]=i;

rear++;

}

}

}

}

}

int inqueue(int n)

{



for(j=front;j<=rear;j++)

{

if(q[j]==n)

return 1;

}

return 0;

}

OUTPUT:

Enter Number of Vertices:5

Enter Adjacency Matrix:

0 1 1 0 0

1 0 1 1 0

1 1 0 0 0

0 1 0 0 1

0 0 0 1 0

Enter Starting Node:1

-->1-->2-->3-->4-->5

EXERCISE: 8

AIM:

Write a C program to implement Prim’s algorithm to generate a min-cost spanning tree.

DESCRIPTION:

Minimum-Cost Spanning Trees:

Let G = (V, E) be a connected graph in which each edge (u, v) Є E has an associated cost C(u, v).

A Spanning Tree for G is a sub-graph of G that it is a free tree connecting all vertices in V. The

cost of a spanning tree is the sum of costs on its edges.

An MST of G is a spanning tree of G having a minimum cost.

See Figure 1 for several examples.



Figure 1: Spanning trees in a connected graph

PRIM'S ALGORITHM:

Initially graph G=(V,E) ,spanning tree T=(V1,E1) where V1={u} and E1={ Ø }

{

while (number of edges are less than or equal to (n-1))

{

, let (u, v) be the lowest cost edge

such that uЄ V1 and vЄ V – V1;

E1= E1 {(u, v)}

V1 = V1 {v}

if no such edge

break;

}

}

See Figure 2 for an example.

Prim’s can be computed in O(n2) time.

Implementation of Prim's Algorithm:



Use two arrays, closest and lowcost.

For i Є V - U, closest[i] gives the vertex in U that is closest to i

For i Є V - U, lowcost[i] gives the cost of the edge (i, closest(i))

PROGRAM:

#include<stdio.h>

#include<conio.h>

int a,b,n,i,j,k,ne;

int min,mincost=0,cost[10][10],V[10];

void main()

{

clrscr();

printf("\n Enter the number of nodes:");

scanf("%d",&n);

printf("\n Enter the adjacency matrix:\n");

for(i=1;i<=n;i++)

{

Figure 2: Illustration of Prim's algorithm



for(j=1;j<=n;j++)

{

scanf("%d",&cost[i][j]);

if(cost[i][j]==0)

cost[i][j]=999;

}

}

V[1]=1;

ne=1;

while(ne<n)

{

min=999;

for(i=1;i<=n;i++)

{

if(inset(i)==1)

{

for(j=1;j<=n;j++)

{

if(inset(j)==0 && cost[i][j]<min)

{

min=cost[i][j];

a=i;

b=j;

}

}

}

}

printf("\n Edge %d:(%d %d) cost:%d",ne,a,b,min);

ne++;

V[ne]=b;

mincost=mincost+min;

cost[a][b]=cost[b][a]=999;



}

printf("\n Minimun cost=%d",mincost);

getch();

}

int inset(int k)

{

int m=1;

while(m<=ne)

{

if(V[m]==k)

return 1;

else

m++;

}

return 0;

}

OUTPUT:

Enter the number of nodes:6

Enter the adjacency matrix:

0 6 1 5 999 999

6 0 5 999 3 999

1 5 0 5 999 4

5 999 5 0 999 2

999 3 999 999 0 6

999 999 4 2 6 0

Edge 1:(1 3) cost:1

Edge 2:(3 6) cost:4

Edge 3:(6 4) cost:2

Edge 4:(3 2) cost:5

Edge 5:(2 5) cost:3

Minimun cost=15



EXERCISE: 9

AIM:

Write a C program to implement Kruskal’s algorithm to generate a min-cost spanning tree.

DESCRIPTION:

Kruskal's algorithm is a greedy algorithm in graph theory that finds a minimum spanning

tree for a connected weighted graph.

This means it finds a subset of the edges that forms a tree that includes every vertex, where the

total weight of all the edges in the tree is minimized.

If the graph is not connected, then it finds a minimum spanning forest (a minimum spanning

tree for each connected component).

Complexity is O(elog e) where e is the number of edges. Can be made even more efficient by a

proper choice of data structures.

KRUSKAL'S ALGORITHM:

Let G = (V, E) be the given graph, with | V| = n

{

Start with a graph T = (V,Ø) consisting of only the vertices of G and no edges;

/* This can be viewed as n connected components, each vertex being one connected

component */

}

PROGRAM: #include<stdio.h>

#include<conio.h>

int i,j,k,u,v,n,ne=1,a,b;

int min,mincost=0,cost[9][9],set[9];

void main()

{

clrscr();

printf("\n\tImplementation of Kruskal's algorithm\n");

printf("\nEnter the no. of vertices:");

scanf("%d",&n);

printf("\nEnter the cost adjacency matrix:\n");

http://en.wikipedia.org/wiki/Greedy_algorithm

http://en.wikipedia.org/wiki/Graph_theory

http://en.wikipedia.org/wiki/Minimum_spanning_tree



http://en.wikipedia.org/wiki/Connectivity_(graph_theory)

http://en.wikipedia.org/wiki/Glossary_of_graph_theory#Weighted_graphs_and_networks

http://en.wikipedia.org/wiki/Edge_(graph_theory)

http://en.wikipedia.org/wiki/Vertex_(graph_theory)

http://en.wikipedia.org/wiki/Connected_component_(graph_theory)



for(i=1;i<=n;i++)

{

for(j=1;j<=n;j++)

{


if(cost[i][j]==0)

cost[i][j]=999;

}

}

for(i=1;i<=n;i++)

set[i]=i;

printf("The edges of Minimum Cost Spanning Tree are\n");

while(ne<n)

{

min=999;

for(i=1;i<=n;i++)

{

for(j=1;j<=n;j++)

{

if(cost[i][j] < min)

{

min=cost[i][j];

a=i;

b=j;

}

}

}

u=find(a);

v=find(b);

if(u!=v)

{

uni(u,v);

printf("%d edge (%d,%d) =%d\n",ne++,a,b,min);

mincost=mincost+min;

}

cost[a][b]=cost[b][a]=999;

}

printf("\n\tMinimum cost = %d\n",mincost);

getch();

}

int find(int i)

{

i=set[i];

return i;

}

int uni(int i,int j)

{



set[j]=i;

for(k=1;k<=n;k++)

{

if(set[k]==j)

set[k]=i;

}

}

OUTPUT:

Implementation of Kruskal's algorithm

Enter the no. of vertices:6

Enter the cost adjacency matrix:

0 6 1 5 999 999

6 0 5 999 3 999

1 5 0 5 999 4

5 999 5 0 999 2

999 3 999 999 0 6

999 999 4 2 6 0

The edges of Minimum Cost Spanning Tree are

1 edge (1,3) =1

2 edge (4,6) =2

3 edge (2,5) =3

4 edge (3,6) =4

5 edge (2,3) =5

Minimum cost = 15

EXERCISE: 10

AIM:

Write a C program to implement Dijkstra’s algorithm to find shortest path in the graph.

DESCRIPTION:

Single Source Shortest Paths Problem: Dijkstra's Algorithm:

Greedy algorithm

It works by maintaining a set S of ``special'' vertices whose shortest distance from the source is

already known. At each step, a ``non-special'' vertex is absorbed into S.

The absorption of an element of V - S into S is done by a greedy strategy.

With adjacency matrix representation, the running time is O(n2)

The following provides the steps of the algorithm.



Example: Consider the digraph in Figure 1.

Figure 1: A digraph example for Dijkstra's algorithm

Initially:S = {1} D[2] = 10 D[3] = ∞ D[4] = 30 D[5] = 100

Iteration 1 Select w = 2, so that S = {1, 2}

D[3] = min( , D[2] + C[2, 3]) = 60 (7.2)

D[4] = min(30, D[2] + C[2, 4]) = 30 (7.3)

D[5] = min(100, D[2] + C[2, 5]) = 100

Iteration 2

Select w = 4, so that S = {1, 2, 4}

D[3] = min(60, D[4] + C[4, 3]) = 50 (7.4)

D[5] = min(100, D[4] + C[4, 5]) = 90

Iteration 3 Select w = 3, so that S = {1, 2, 4, 3}

D[5] = min(90, D[3] + C[3, 5]) = 60

Iteration 4 Select w = 5, so that S = {1, 2, 4, 3, 5}

D[2] = 10 (7.5)

D[3] = 50 (7.6)

D[4] = 30 (7.7)

D[5] = 60


#include<conio.h>



int s,u,n,i,j,cost[10][10],d[10],found[10],pre[10];

void shortest_path()

{

for(i=1;i<=n;i++)

{

found[i]=0;

d[i]=cost[s][i];

pre[i]=s;

}

found[s]=1;

for(i=1;i<n-1;i++)

{

u=choose();

found[u]=1;

for(j=1;j<=n;j++)

{

if(!found[j])

{

if(d[u]+cost[u][j] < d[j])

{

d[j]=d[u]+cost[u][j];

pre[j]=u;

}

}

}

}

}

int choose()

{

int i,j,min=999,minpos=-1;

for(i=1;i<=n;i++)

{

if(d[i]<min && !found[i])

{

min=d[i];

minpos=i;

}

}

return minpos;

}

path(int i)

{

printf("%d",i);

while(i!=s)

{

i=pre[i];



printf("<--%d",i);

}

}

void main()

{

clrscr();

printf("\nEnter Number of Nodes:");

scanf("%d",&n);

printf("\nEnter Cost Matrix:\n");

for(i=1;i<=n;i++)

{

for(j=1;j<=n;j++)

{


if(cost[i][j]==0)

cost[i][j]=999;

}

}

printf("\nEnter Source Node:");

scanf("%d",&s);

shortest_path();

printf("\nNODE\tSHORTEST PATH\t\tPATH COST\n");

printf("------------------------------------------------------\n");

for(i=1;i<=n;i++)

{

if(i!=s && d[i]!=999)

{

printf("%d\t",i);

path(i);

printf("\t\tMinimum Cost :%d\n",d[i]);

}

}

getch();

}

OUTPUT:

Enter Number of Nodes:5

Enter Cost Matrix:

0 10 999 30 100

0 0 50 999 999

999 999 0 999 10

999 999 20 999 60

999 999 999 999 0

Enter Source Node:1



NODE SHORTEST PATH PATH COST

------------------------------------------------------

2 2<--1 Minimum Cost :10

3 3<--4<--1 Minimum Cost :50

4 4<--1 Minimum Cost :30

5 5<--3<--4<--1 Minimum Cost :60

EXERCISE: 11

AIM:

Write a C program to implement pattern matching using Boyer-Moore algorithm.

DESCRIPTION:

Boyer Moore Pattern Matching Algorithm:

The Boyer-Moore pattern matching algorithm is based on two techniques.

1. The looking-glass technique: find P in T by moving backwards through P, starting at

its end.

2. The character-jump technique: when a mismatch occurs at T[i] == xth character in

pattern P[j] is not the same as T[i]. There are 3 possible cases, tried in order.

Case 1

• If P contains x somewhere, then try to shift P right to align the last occurrence of x in P with T[i].

x aT

i

b aP

j

x c

x aT

inew

b aP

jnew

x c

and move i and j right, soj at end



Case 2

• If P contains x somewhere, but a shift right to the last occurrence is not possible, thenshift P right by 1 character to T[i+1].

a xT

i

a xP

j

c w

a xT

inew

a xP

jnew

c w


x

x is after j position

x

Case 3

• If cases and do not apply, then shift P to align P[ ] with T[i+

x aT

i

b aP

j

d c

x aT

inew

b aP

jnew

d c


No x in P



Boyer-Moore Example 1

1

a p a t t e r n m a t c h i n g a l g o r i t h m

r i t h m

r i t h m

r i t h m

r i t h m

r i t h m

r i t h m

r i t h m

2

3

4

5

6

7891011

T:

P:

Boyer-Moore Example 2

1

a b a c a a b a d c a b a c a b a a b b

234

5

6

7

891012

a b a c a b

a b a c a b

a b a c a b

a b a c a b

a b a c a b

a b a c a b

1113

-1354L(x)

dcbax

T:

P:

Last occurrence function L ( ): Boyer-Moore’s algorithm preprocesses the pattern P and the

alphabet A to build a last occurrence function L ().

L() maps all the letters in A to integers,

L(x) is defined as: // x is a letter in Athe largest index i such that P[i] == x, or -1 if no such

index exists

In Boyer-Moore code, L() is calculated when the pattern P is read in.



L() Example

• A = {a, b, c, d}

• P: "abacab"

-1354L(x)

dcbax

a b a c a bP

L() stores indexes into P[]

ANALYSIS:

Boyer-Moore worst case running time is O(nm + A).

But, Boyer-Moore is fast when the alphabet (A) is large, slow when the alphabet is small. e.g.

good for English text, poor for binary.

Boyer-Moore is significantly faster than brute force for searching English text.

ALGORITHM: Algorithm BMP (T, P, S)

{

L lastOccurenceFunction(P, S )

im -1

jm -1

while(n<i)

{

ifT[i]= P[j]

{

if j=0

return i { match at i }

else

ii-1

jj-1

}

else

{

//character-jump

ii+ m – min(j, 1 + L[T[i]])

jm -1

}

return -1{ no match }

}



PROGRAM: #include<stdio.h> #include<conio.h> #include<string.h> char t[30],p[15]; int last[15]; main() { int pos,i; clrscr(); printf("\n enter text: "); scanf("%s",t); printf("\n enter pattern: "); scanf("%s",p); /* calculate last function */ for(i=0;p[i]!='\0';i++) last[p[i]]=i; pos=pattern_match(); if(pos==-1) printf("\n given pattern is not matched"); else printf("\n pattern is matched at : %d",pos+1); getch(); } int pattern_match() { int n,m,i,j; n=strlen(t); m=strlen(p); i=m-1; j=m-1; while(i<n) { if(t[i]==p[j]) { if(j==0) return i; else



{ i--; j--; } } else { i=i+m-min(j,1+last[t[i]]); j=m-1; } } return(-1); } int min(int x,int y) { if(x<y) return x; else return y; }

OUTPUT:

enter text: abcbaabbcabc

enter pattern: bcab

pattern is matched at : 8

enter text: aabbabcbba

enter pattern: bbaa

given pattern is not matched



EXERCISE: 12 AIM:

Write a C program to implement Knuth-Morris-Pratt algorithm for pattern matching.

DESCRIPTION:

KMP Failure Function

• Knuth-Morris-Pratt’s algorithmpreprocesses the pattern to findmatches of prefixes of thepattern with the pattern itself

• The failure function F(j) isdefined as the size of the largestprefix of P[0..j] that is also asuffix of P[1..j]

• Knuth-Morris-Pratt’s algorithmmodifies the brute-forcealgorithm so that if a mismatchoccurs at P[j] T[i] we set j

F(j - 1)

j 0 1 2 3 4 5

P[j] a b a a b a

F(j) 0 0 1 1 2 3

x

j

. . a b a a b . . . . .

a b a a b a

F(j-1)

a b a a b a

ALGORITHM:

The KMP Algorithm

• The failure function can berepresented by an array and canbe computed in O(m) time

• At each iteration of the while-loop, either

– i increases by one, or

– the shift amount i - j increasesby at least one (observe that F(j

- 1) < j)

• Hence, there are no more than2n iterations of the while-loop

• Thus, KMP’s algorithm runs inoptimal time O(m + n)

Algorithm KMPMatch(T, P)

F failureFunction(P)i 0j 0while i < n

if T[i] = P[j]if j = m - 1

return i - j { match }else

i i + 1j j + 1

elseif j > 0

j F[j - 1]else

i i + 1return -1 { no match }



Computing the Failure Function

• The failure function can berepresented by an array and can becomputed in O(m) time

• The construction is similar to theKMP algorithm itself

• At each iteration of the while-loop,either

– i increases by one, or

– the shift amount i - j increases byat least one (observe that F(j - 1)

< j)

• Hence, there are no more than 2m

iterations of the while-loop

Algorithm failureFunction(P)

F[0] 0i 1j 0while i < m

if P[i] = P[j]{we have matched j + 1

chars}F[i] j + 1i i + 1j j + 1

else if j > 0 then{use failure function to

shift P}j F[j - 1]

elseF[i] 0 { no match }i i + 1

Example

1

a b a c a a b a c a b a c a b a a b b

7

8

19181715

a b a c a b

1614

13

2 3 4 5 6

9

a b a c a b

a b a c a b

a b a c a b

a b a c a b

10 11 12

c

j 0 1 2 3 4 5

P[j] a b a c a b

F(j) 0 0 1 0 1 2

ALGORITHM:

int KMPmatch(T,P)

{

FailureFunction(P);

n=strlen(T);

m=strlen(P);

i=0;

j=0;

while(i<n)

{

if(p[j]==t[i])

{

if(j==m-1)

return i-(m-1);

else

{

i++;

j++;



}

}

else if(j>0)

j=f[j-1];

else

i++;

}

return -1;

}


#include<conio.h>

#include<string.h>

char t[30],p[15];

int f[15],i,j,n,m;

main()

{

int pos;

clrscr();

printf("\n enter text: ");

scanf("%s",t);

printf("\n enter pattern: ");

scanf("%s",p);

m=strlen(p);

n=strlen(t);

failurefunction();

pos=KMPmatch();

if(pos==-1)

printf("\n Pattern: %s Not Found",p);

else

printf("\n Pattern is matched at : %d",pos+1);

getch();

}

int KMPmatch()

{

i=0;

j=0;

while(i<n)

{

if(p[j]==t[i])

{

if(j==m-1)

return i-(m-1);

else

{

i++;

j++;



}

}

else if(j>0)

j=f[j-1];

else

i++;

}

return -1;

}

failurefunction()

{

i=1;

j=0;

f[0]=0;

while(i<m)

{

if(p[j]==p[i])

{

f[i]=j+1;

i++;

j++;

}

else if(j>0)

j=f[j-1];

else

{

f[i]=0;

i++;

}

}

}

OUTPUT: Case 1:

enter text: abcaabba

enter pattern: abba

Pattern is matched at : 5

Case 2:

Enter text: advanced data structures

Enter pattern : ads

Pattern is not matched.



ADDITIONAL PROGRAMS

EXERCISE: 1

AIM:

a) Write a C program to implement Floyd’s algorithm to find the shortest path in the given graph.

DESCRIPTION: This algorithm is designed to find the least-expensive paths between all the vertices in a graph. It

does this by operating on a matrix representing the costs of edges between vertices.

Before we invoke Floyd's algorithm we must build a matrix, usually in a two-dimensional

array.

Floyd’s algorithm uses Dynamic Programming design strategy.

If there are n vertices in our graph, our matrix will be nxn. Each row in the matrix represents a

"starting" vertex in the graph while each column in the matrix represents an "ending" point in

the graph.

A representation: a weight/cost matrix where

C(i,j)=0 if i=j.

C(i,j)=infinity if there is no edge between i and j.

C(i,j)=“weight of edge”

Recursive Definition:

Case 1:

A shortest path from vi to vj restricted to using only vertices from {v1,v2,…,vk} as

intermediate vertices does not use vk. Then D(k)

[i,j]= D(k-1)

[i,j].

Case 2:

A shortest path from vi to vj restricted to using only vertices from {v1,v2,…,vk} as

intermediate vertices does use vk. Then D(k)

[i,j]= D(k-1)

[i,k]+ D(k-1)

[k,j].



FLOYD’S ALGORITHM: // Floyd Computes shortest distance between all pairs of nodes, and saves P to enable finding shortest

paths

1. D0 W // initialize D array to W [ ]

2. P 0 // initialize P array to [0]

3. for k 1 to n

4. do for i 1 to n

5. do for j 1 to n

6. if (Dk-1

[ i, j ] > Dk-1

[ i, k ] + Dk-1

[ k, j ] )

7. then Dk[ i, j ] D

k-1 [ i, k ] + D

k-1 [ k, j ]

8. P[ i, j ] k;

9. else Dk[ i, j ] D

k-1 [ i, j ]

It is clear that Floyd's algorithm takes n3 time where as Dijkstra’s algorithm takes n

2 time. It is

important to note, however, that for dense graphs (i.e. graphs with many edges) Floyd's algorithm

is as good as or better than Dijkstra's algorithm.


#include<conio.h>

#define infinity 999

void main()

{

int i,j,k,path[10][10],cost[10][10],a[10][10],n;

clrscr();

printf("\n enter no of vertices: ");

scanf("%d",&n);

printf("\n enter cost adjacency matrix ( -1 for infite edge and 0 for (i,i) )...");

for(i=1;i<=n;i++)

for(j=1;j<=n;j++)

{

printf("\n enter a[%d][%d]: ",i,j);


if(cost[i][j]==-1)

{

cost[i][j]=infinity;

}

a[i][j]=cost[i][j];

path[i][j]=-1;

}

for(k=1;k<=n;k++)

{

printf("\n A%d matrix is...\n",k);

for(i=1;i<=n;i++)

{



for(j=1;j<=n;j++){

if(a[i][j]>a[i][k]+a[k][j])

{

a[i][j]=a[i][k]+a[k][j];

path[i][j]=k;

}

printf(" %d\t",a[i][j]);

}

printf("\n");

} }

printf("\n path matrix is...\n");

for(i=1;i<=n;i++)

{

for(j=1;j<=n;j++)

printf(" %d\t",path[i][j]);

printf("\n");

} getch();

}

OUTPUT:

Enter no of vertices:3

enter cost matrix(-1 for infinity) && (0 for (i,i))

enter a[1][1]: 0

enter a[1][2]: 1

enter a[1][3]: 1

enter a[2][1]: 0

enter a[2][2]: 1

enter a[2][3]: 0

enter a[3][1]: 1

enter a[3][2]: 0

enter a[3][3]: 1

A1 matrix is

0 1 1

0 1 0

1 0 1

path matrix.....

-1 -1 -1

-1 -1 -1

-1 -1 -1



AIM:

b) Write a C program to implement Warshall’s algorithm to find the shortest path in the given

graph.

DESCRIPTION:

Warshall's algorithm is an efficient method for computing the transitive closure of a relation.

Warshall's algorithm takes as input the matrix MR representing the relation R and outputs the matrix

MR* of the relation R* the transitive closure of R.

The input to this algorithm is an adjacency matrix, which has 1s for any row-column pair if there

exists an edge between them. What we'll be doing here is -- checking out for every vertex, the

incoming and outgoing links.

If there exist both incoming and outgoing links for a particular vertex, we will put a 1 for the row-

column pair formed by them in the adjacency matrix.

Given the adjacency matrix C of any digraph C = (v,E), the matrix A is called the transitive closure

of C.

A[i, j] = 1 if there is a path of length one or more from vertex i to vertex j

= 0 Otherwise

Warshall's algorithm predates Floyd's algorithm and simple uses the following formula in the kth

passes of Floyd's algorithm:

Ak[i, j] = Ak - 1[i, j] (Ak - 1[i, k] Ak - 1[k, j])

where the matrix elements are treated as boolean values 0 or 1 and the

symbols and denote ``logical or'' and ``logical and'' respectively. It is easy to see that

Warshall's algorithm has a worst case complexity of O(n3) where n is the number of vertices of

the graph.

http://datastructures.itgo.com/graphs/adjmat.htm



WARSHALL ’S ALGORITHM:

Step-1: Copy the Adjacency matrix into another matrix called the Path matrix

Step-2: Find in the Path matrix for every element in the Graph, the incoming and outgoing edges

Step-3: For every such pair of incoming and outgoing edges put a 1 in the Path matrix

It is clear that Warshall's algorithm also takes n3 time to compute and this algorithm also follows

Dynamic Programming design strategy.

Example:

The matrix MR below is the matrix representation for a relation R. Find the matrix

representation MR* of R*, the transitive closure of R.

Solution:

We know that W0=MR.

To compute W1 we notice that in the first column of W0 there are 1’s in rows 1 and 4. Thus, we

replace rows 1 and 4 with the OR of themselves and row 1.

We obtain

To compute W2 we notice that in the second column of W1 there is a 1 in row 3. Thus, we replace

row 3 with the OR of rows 3 and 2, obtaining.



To compute W3 we notice that in the third column of W2 there is a 1 in every row. Thus, we

replace each row with the OR of itself and row 3, obtaining.

To compute W4 we notice that in the fourth column of W3 there is a 1 in every row. Thus, we

replace each row with the OR of itself and row 4, obtaining.



PROGRAM:

/*bwarshals*/

#include<stdio.h>

#include<conio.h>

void main()

{

int i,j,k,n,a[10][10];

clrscr();

printf("\n enter no.of vertices:");

scanf("%d",&n);

for(i=1;i<=n;i++)

{

for(j=1;j<=n;j++)

{

printf("enter %d-%d:",i,j);

scanf("%d",&a[i][j]);

}

}

for(k=1;k<=n;k++)

{

printf("\n A %d matrix is.....\n",k);

for(i=1;i<=n;i++)

{

for(j=1;j<=n;j++)

{

a[i][j]=a[i][j]||a[i][k]&&a[k][j];

printf("%d\t",a[i][j]);

}

printf("\n");

getch();

}

}

}



OUTPUT:

enter no of vertices: 4

enter a[1][1]: 0

enter a[1][2]: 1

enter a[1][3]: 1

enter a[1][4]: 0

enter a[2][1]: 0

enter a[2][2]: 0

enter a[2][3]: 1

enter a[2][4]: 1

enter a[3][1]: 0

enter a[3][2]: 0

enter a[3][3]: 0

enter a[3][4]: 1

enter a[4][1]: 1

enter a[4][2]: 0

enter a[4][3]: 0

enter a[4][4]: 0



A1 matrix is

0 1 1 0

0 1 1 1

0 1 1 1

1 1 1 1

A2 matrix is

1 1 1 1

1 1 1 1

1 1 1 1

1 1 1 1

A3 matrix is

1 1 1 1

1 1 1 1

1 1 1 1

1 1 1 1

A4 matrix is

1 1 1 1

1 1 1 1

1 1 1 1

1 1 1 1

gudlavalleru engineering college seshadri rao...

Documents