Data Structure

Jawaharlal Nehru Engineering College

Laboratory Manual

Lab manual made by

PROF. S.S.KULKARNI

DATA STRUCTURE

For

Second Year Students

(Electronics And Telecommunication)

Author JNEC, Aurangabad

FORWARD

It is my great pleasure to present this laboratory manual for Second year engineering students for the

subject of Data Structures & Numerical Computing keeping in view the vast coverage required for

visualization of concepts of Data Communication with simple language.

As a student, many of you may be wondering with some of the questions in your mind regarding the

subject and exactly what has been tried is to answer through this manual.

As you may be aware that MGM has already been awarded with ISO 9000 certification and it is our

endurance to technically equip our students taking the advantage of the procedural aspects of ISO

9000 Certification.

Faculty members are also advised that covering these aspects in initial stage itself, will greatly relived

them in future as much of the load will be taken care by the enthusiasm energies of the students once

they are conceptually clear.

Dr. S. D. Deshmukh

Principal

LABORATORY MANUAL CONTENTS

This manual is intended for the Second year students of IE branches in the subject of Data Structures

& Numerical Computing. This manual typically contains practical/Lab Sessions related Data

Structures covering various aspects related the subject to enhanced understanding.

We have made the efforts to cover various aspects of the subject covering computer hardware

components, software components networking aspects, Operating System concepts and programming

aspects will be complete in itself to make it meaningful, elaborative understandable concepts and

conceptual visualization.

Students are advised to thoroughly go though this manual rather than only topics mentioned in the

syllabus as practical aspects are the key to understanding and conceptual visualization of theoretical

aspects covered in the books.

Good Luck for your Enjoyable Laboratory Sessions.

SUBJECT INDEX

1. Lab Exercises 1: Program for merging of two arrays.

2. Lab Exercises 2: Program using function and pointers.

3. Lab Exercises 3: Program to implement stack.

4. Lab Exercises 4: Program to implement queue.

5. Lab Exercises 5: Program to implement singly linked list.

6. Lab Exercises 6: Program to implement graph traversal.

7. Lab Exercises 7: Program to implement binary search tree.

8. Lab Exercises 8: Program to implement bubble sort.

.Conduction of Viva-Voce Examinations

.Submission

.Evaluation and marking system

DOs and DONTs in Laboratory:

1. Do not handle any equipment before reading the instructions/Instruction manuals

2. Read carefully the power ratings of the equipment before it is switched on whether ratings 230

V/50

Hz or 115V/60 Hz. For Indian equipments, the power ratings are normally 230V/50Hz. If you have

equipment with 115/60 Hz ratings, do not insert power plug, as our normal supply is 230V/50 Hz,

which will damage the equipment.

3. Observe type of sockets of equipment power to avoid mechanical damage

4. Do not forcefully place connectors to avoid the damage

5. Strictly observe the instructions given by the teacher/Lab Instructor

Instructions for Laboratory Teachers:

1. Submission related to whatever lab work has been completed should be done during the next lab

session. The immediate arrangements for printouts related to submission on the day of practical

assignments.

2. Students should be taught for taking the printouts under the observation of lab teacher.

3. The promptness of submission should be encouraged by way of marking and evaluation patterns

that will benefit the sincere students.

Lab Exercises 1

Program for merging of two arrays.

#include

#include

void main()

{

int i,j,n1,n2,n3;

int a[10],b[10],c[20];

printf("\n enter no of elements of 1st array");

scanf("%d",&n1);

printf("\n now enter those elements");

for(i=0;i

Lab Exercises 2

Program using function and pointers.

#include

#include

void swap (int *x,int*y);

void main()

{

inta,b;

a=10;

b=20;

printf("value of a before function call %d \n",a);

printf("value of b before function call %d \n",b);

swap(&a,&b);

printf("value of a after funtion call %d\n",b);

getch();

}

void swap(int*x,int*y)

{

int temp;

*x=*y;

*y=temp;

printf("value of a during function call &%d\n",*x);

printf("value of b during function call %d \n",*y);

}

Lab Exercises 3

Program to implement stack.

Review:

1. A collection of data and its relationship among the elements forms a data structure. 2. A stack is ordered collection of items in which all insertion, deletion are done at the same end

called the top.

3. The basic operations on stack are push and pop. It is often called LIFO data structure. 4. A Queue is a non-primitive linear data structure. It is ordered collection of element in which

elements are added at one end called rear and elements are deleted at other end called front.

5. The basic operations on Queue are insert and delete. It is called as FIFO data structure. 6. A circular queue is implemented by visualizing the 1D array as circular queue. The circular

queue overcomes the problems associated when the deletion is made from the front, it gives

queue full condition even if in reality, it is empty.

1.2 Operations on Stack:

1.2.1 Algorithm to push an element:

1. Check whether stack is full or not. (i.e. if(top==MAXSIZE)) 2. Otherwise increase the top by 1(else top=top+1) 3. Insert the element, elem.

stack[top]=elem;

1.2.2 Algorithm to pop an element:

1. Check whether stack is empty or not (if (top==-1)) 2. Otherwise decrement top by 1.

1.2.3 To check whether the stack is empty or not (STACK EMPTY).

1.2.4 To check whether the stack is full or not (STACK FULL).

/*Program demonstrate the operations performed on stack*/

#include

#include

#include

#define MAXSIZE 10

void push ();

int pop ();

void display ();

int top=-1;

int stack[MAXSIZE];

void main()

{

int choice;

clrscr();

do

{

printf("\n1.PUSH");

printf("\n2.POP");

printf("\n3.DISPLAY");

printf("\n4.EXIT");

printf("\nenter your choice");

scanf("\n%d",&choice);

switch(choice)

{

case 1:push();

break;

case 2:printf("\ndeleted item is %d",pop());

break;

case 3:display();

break;

case 4:printf("\nexit");

exit(0);

break;

}

}while(choice!=4);

getch();

}

void push()

{

int item;

if(top==MAXSIZE-1)

{

printf("\nSTACK IS FULL");

getch();

return(0);

}

else

{

printf("\nenter element");

scanf("%d",&item);

top=top+1;

stack[top]=item;

}

}

int pop()

{

int item;

if(top==-1)

{

printf("\nSTACK EMPTY");

getch();

return;

}

else

{

item=stack[top];

top=top-1;

return(item);

}

}

void display()

{

int i;

if(top==-1)

{

printf("\nstack is empty");

}

else

{

printf("\nthe elements are:");

for(i=top;i>=0;i--)

{

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

}

}

}

Output:-

1.PUSH

2.POP

3.DISPLAY

4.EXIT

enter your choice 1

enter element 10

1.PUSH

2.POP

3.DISPLAY

4.EXIT

enter your choice 1

enter element 20

1.PUSH

2.POP

3.DISPLAY

4.EXIT

enter your choice 3

the elements are: 20 10

1.PUSH

2.POP

3.DISPLAY

4.EXIT

enter your choice 4

Lab Exercises 3

Program to implement queue.

1.3 Operations on Queue:

1.3.1 Algorithm to insert an element in Queue:

1. Initialize front=0, rear=-1 and MAXSIZE=5. 2. If rear>=MAXSIZE //condition for queue full

Print Queue Overflow and return Else

Increment rear by 1.

3. Insert item, q[rear]=item; 4. For insertion of more elements goto step2.

1.3.2 Algorithm to delete an element from Queue:

1. If front

/*Program to demonstrate operations on queue*/

#include

#include

#include

#define MAXSIZE 10

int front=-1,rear=0;

void cqinsert();

int cqdelete();

void display();

int cqueue[MAXSIZE];

int option;

char ch;

void main()

{

clrscr();

do

{

printf("\n1.insert");

printf("\n2.delete");

printf("\n3.display");

printf("\n4exit");

printf("\nenter your choice");

scanf("%d",&option);

switch (option)

{

case 1:cqinsert();

break;

case 2:printf("\ndeleted item is %d",cqdelete());

break;

case 3:display();

break;

case 4:printf("\nexit");

exit(0);

break;

}

}while(option!=4);

getch();

}

void cqinsert()

{

int num;

if(front==(rear+1)%MAXSIZE)

{

printf("\nqueue overflow");

getch();

}

else

{

printf("\nenter element to be inserted");

scanf("%d",&num);

if(front==-1)

front=rear=0;

else

front=(rear+1)%MAXSIZE;

cqueue[rear]=num;

}

}

int cqdelete()

{

int num;

if(front==-1)

{

printf("queue underflow");

getch();

return 0;

}

else

{

num=cqueue[front];

front=rear+1;

}

}

void display()

{

int i;

if(front==-1)

{

printf("\nqueue underflow");

}

else

{

printf("\nelements of queue are");

for(i=front;irear)

{

for(i=front;i

2.delete

3.display

4.exit

enter your choice 4

Lab Exercises 5

Program to implement singly linked list.

Review

1. Static memory allocation may insert in wastage of memory and also shortage of memory. (Like in array implementations)

2. To outcome these problems, dynamic memory allocation is used. 3. Linked list is a linear data structure which consists of number of nodes created dynamically. 4. A linked list has no fix size but grows or shrinks as elements are added or deleted from the

list.

5. A singly linked list is a dynamic data structure. It may grow or shrink. Growing or shrinking depends on operation made.

6. Every node of list has two fields, information and next address. Next address field contains memory address location of next node.

7. A doubly linked list maintains two links, to previous node and next node. We can delete or insert a node given only a pointer.

2.2 Operations on Singly Linked List:

2.2.1 Algorithm for inserting a node at the beginning

1. Allocate memory for the new node, temp=malloc(). 2. Assign the value of the data field of the new node, temp->info 3. Make the link field of the new node to point to the starting node of the linked list, temp-

>next=start.

4. Then, set the external pointer (which was pointing to the starting node) to point to the new node, start=temp.

2.2.2 Algorithm for inserting a node at the end

1. If the list is empty then create the new node, temp=malloc (). 2. If the list is not empty, then go to the last node and then insert the new node after the last

node, r=start; go till last node then r->next=temp.

2.2.3 Algorithm for inserting node at the specified position

1. Allocate memory for the new node, temp=malloc (). 2. Assign value to the data field of the new node, temp->info. 3. Go till node R, also mark next node as S. 4. Make the next field of node temp to node S and next field of node R to point to new node.

2.2.4 Algorithm for deleting the first node

1. Mark the first node as temp. 2. Then, make start point to the next node. 3. Make next field of temp, null. 4. Free temp.

2.2.5 Algorithm for deleting the last node

1. Mark the last node as temp & last but one node as R. 2. Make the next field of R as NULL. 3. Free temp.

2.2.6 Algorithm for deleting a middle node

1. Mark the node to be deleted as temp. 2. Mark the previous node as R & next nodes as S. 3. Make the next field of R to point S. 4. Make the next field of temp, NULL. 5. Free Temp.

/*Program to demonstrate operation on singly linked list*/

#include

#include

lude

#include

#include

struct node

{

int info;

struct node*next;

}*start;

void insert();

void display();

void delete1();

void search();

void main()

{

int ch;

start=NULL;

clrscr();

do

{

printf("\n1.insert");

printf("\n2.delete");

printf("\n3.display");

printf("\n4.search");

printf("\n5.exit");

printf("\n enter your choice");

scanf("%d",&ch);

switch(ch)

{

case 1:printf("\n insert node at any position");

insert();

break;

case 2:printf("\n delete a node");

delete1();

break;

case 3:printf("\n display list");

display();

break;

case 4:printf("\n search for an node");

search();

break;

case 5:printf("\n exit");

//break;

exit(0);

}

}while(ch!=5);

getch();

}

void insert()

{

struct node*temp,*r,*s;

int inf;

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

temp->next=NULL;

printf("\n enter information");

scanf("%d",&temp->info);

if(start==NULL)

{

start=temp;

}

else

{

printf("\n after which you want to insert");

scanf("%d",&inf);

r=start;

while(r->info!=inf)

{

r=r->next;

}

s=r->next;

r->next=temp;

temp->next=s;

}

}

void display()

{

struct node*temp;

temp=start;

if(temp==NULL)

{

printf("\n linked list is empty");

return;

}

else

{

do

{

printf("\n %d",temp->info);

temp=temp->next;

}while(temp!=NULL);

}

}

void delete1()

{

struct node*temp,*r;

int inf;

printf("\n which item you want to delete");

scanf("%d",&inf);

temp=start;

if(temp==NULL)

{

printf("\n linked list is empty");

return;

}else

{

while(temp->info!=inf);

{

temp=temp->next;

}

if(temp->next==NULL)

{

printf("\n deleted node is %d",temp->info);

r=start;

while(r->next!=temp);

{

r=r->next;

}

r->next=NULL;

}

else if(temp==start)

{


start=start->next;

temp->next=NULL;

}

else

{


r=start;

while(r->next!=temp);

{

r=r->next;

}

r->next=temp->next;

temp=temp=NULL;

}

free(temp);

}

}

void search()

{

int inf;

struct node*temp;

printf("\n enter item which we want to search");

scanf("%d",&inf);

temp=start;

do

{

if(temp->info==inf)

{

printf("\n item found");

return;

}

else

{

temp=temp->next;

}

}while(temp!=NULL);

printf("\n item not found");

}

Lab Exercises 6

Program to implement graph traversal.

Review:

1. A graph G consists of two sets V and E. Set V is a finite non empty set of vertices and E is a set of pairs of vertices called edges.

2. There are two possible orders for visiting the vertices of the graph, Depth First Search (DFS) and Breadth First Search (BFS).

3. DFS of an undirected graph is roughly analogous to preorder traversal of an ordered tree. 4. In DFS we traverse a single path of the graph as far as it can go i.e. until it lists a node

with no successors or a node all of whose successors have already been visited.

5. In BFS all unvisited vertices adjacent to V are visited after visiting the starting vertex V and marking it as visited. Next the unvisited vertices adjacent to these vertices are visited

and so on until the entire graph has been traversed. BFS uses queue to store the nodes of

each level of the graph.

5.2 Algorithm fro Depth First Search

1. Select any unvisited node in the graph. Mark this node as visited, push this on to the stack. 2. Find the adjacent node on TOS (top of stack), and which is not yet visited, mark this new

node as visited & push on to stack.

3. Repeat step 2 until no new node to TOS node can b found, when no new adjacent node can be found, pop TOS.

4. Repeat step 2 and 3 till stack becomes empty. 5. Repeat step 1 till any more nodes which are still unvisited- USE ADJANCY MATRIX for

finding adjacent nodes.

5.3 Algorithm for Breadth First Search

1. Select any unvisited node in the graph. Mark this node as visited. Insert this node into the queue.

2. Find all the adjacent nodes (one by one) or node present in the front end of the queue & which is not yet visited, mark this node as visited & insert it in to the queue.

3. Repeat step 2, till queue becomes empty. 4. Repeat step 1, till any more nodes which are still unvisited.

/**Program to traverse a graph using DFS**/

#include

#include

void creatadjm(int adj[10][10],int);

void dfs(int,int visited[10],int adj[10][10],int);

void main()

{

int adj[10][10],node,n;

int i,visited[10];

clrscr();

printf("\n Enter the no. of nodes in graph,max=10");

scanf("%d",&n);

creatadjm(adj,n);

for(i=0;i

Lab Exercises 7

Program to implement binary search tree.

Review:

1. Trees are non linear data structures that can be used to represent data items processing hierarchical relationship between them.

2. Binary search tree may be used to store ordered information which can reduce search time for any particular element.

3. Trees can be traversed in inorder, preorder and postorder. 4. Inorder traversal of binary search tree will result in elements arranged in ascending order. 5. Binary trees can be used to evaluate mathematical expressions

4.2 Algorithm for creation of binary tree and inserting an element

1. Read an element, make it root node. 2. Read next element, elm, compare it with the root node, if it is less then insert it in left else

insert right.

3. Repeat step 2 till you insert all elements.

4.3 Traversal Methods:

4.3.1 Algorithm for Preorder Traversal

1. Visit the node. 2. Traverse the left sub-tree in preorder. 3. Traverse the right sub-tree in preorder.

4.3.2 Algorithm for Inorder Traversal

1. Traverse the left sub-tree in inorder. 2. Visit the node. 3. Traverse the right sub-tree in inorder.

4.3.3 Algorithm for Postorder Traversal

1. Traverse the left sub-tree in postorder. 2. Traverse the right sub-tree in postorder. 3. Visit the node.

/*prgram to create binary tree n traverse it*/

#include

#include

#include

void insert(struct node *r,struct node *p);

void preorder(struct node *r);

void inorder(struct node *r);

void postorder(struct node *r);

struct node

{

int info;

struct node *lchild,*rchild;

}*root,*p;

void main()

{

int i,ch=0;

clrscr();

root=NULL;

while(ch!=5)

{

printf("\n1:Insert 2:Preorder 3:Inorder 4:Postorder 5:Exit");

scanf("%d",&ch);

switch(ch)

{

case 1:p=(struct node*)malloc(sizeof(struct node));

printf("Enter the element");

scanf("%d",&i);

p->info=i;

p->lchild=NULL;

p->rchild=NULL;

if(root==NULL)

{

root=p;

}

else

insert(root,p);

break;

case 2:printf("%s","tree traversal is preorder is");

preorder(root);

break;

case 3:printf("%s","tree traversal is inorder is");

inorder(root);

break;

case 4:printf("%s","tree traversal is postorder is");

postorder(root);

break;

}

}

}

void insert(struct node *r,struct node *q)

{

if(q->info < r->info)

{

if(r->lchild==NULL)

{

r->lchild=p;

printf("\n element:%d is inserted on left of:%d",p->info,r->info);

}

else

insert (r->lchild,p);

}

else

{

if(r->rchild==NULL)

{

r->rchild=p;

printf("\n element:%d is inserted on right of:%d",p->info,r->info);

}

else

insert(r->rchild,p);

}

}

void preorder(struct node *r)

{

if(r!=NULL)

{

printf("%d\t",r->info);

preorder(r->lchild);

preorder(r->rchild);

}

}

void inorder(struct node *r)

{

if(r!=NULL)

{

inorder(r->lchild);


inorder(r->rchild);

}

}

void postorder(struct node *r)

{

if(r!=NULL)

{

postorder(r->lchild);

postorder(r->rchild);


}

}

0/*OUTPUT */

1.Insert 2.Preorder 3. Inorder 4. Postorder 5.Exit1

Enter the element55


Enter the element88

Element:88 is inserted on right of :55


Enter the element22

Element:22 is inserted on right of :55


Enter the element54

Element:54 is inserted on right of: 22


Enter the element54

Element :66 is inserted on left of :88


Enter the element10

Element :10 is inserted on left of:22


Tree traversed in preorder is 55 22 10 54 88 66






Lab Exercises 8:

Program to implement bubble sort.

Review:

1. The choice of particular algorithm depends upon following performance analysis and measurements

a. Space Complexity. b. Time Complexity.

2. Analysis of Space complexity of a program is the amount of memory it needs to run to completion.

3. The time complexity of an algorithm of a program is the amount of time it needs to run to completion.

4. Sorting and searching are among the most common topics for programming systems. Big Oh (O), Omega () and theta () notations are most commonly used to describe the efficiency of a program. It describes the behavior of time or space complexity for large instance

characteristics.

5. In bubble sort, each element is compared with its adjacent elements, if the first element is larger than the second one then the positions of the elements are interchanged otherwise it is

not changed then next element is compared with its adjacent element and the same process is

repeated for all the elements in the array until we get a sorted array.

6. The total number of comparisons for bubble sort is n2 -2n+1, therefore, time complexity of bubble sort is O(n

2)

6.1.1 Bubble Sort Algorithm:

Let A be a linear array of n numbers. Temp is a temporary variable for swapping (or interchange) the

position of the numbers.

1. Input n numbers to an array A 2. Initialize i=0 and repeat through step 4 if (i

/** PROGRAM FOR BUBBLE SORT **/

#include

#include

#define max 30

void main()

{

int arr[max],i,j,k,temp,n;

clrscr();

printf("Enter the number of elements:");

scanf("%d",&n);

for(i=0;i

/* OUTPUT */

Enter the no. of elements: 4

Enter element 1: 101

Enter element 2: 98



Unsorted list is

101

98

212

301

After pass 1 elements are:

98

101

212

301


98

101

212

301


98

101

212

301

Sorted list is

98

101

212

301

Documents

Data Structure