DATASTRUCTURES USING C

LAB EXERCISES
EX NO 1: PROGRAM TO INSERT DELETE AN ELEMENT IN AN ARRAY PRINT THE
POSITION OF PARTICULAR ELEMENT

AIM:

To write a C program to perform an insert, delete operation in an array also print the position
of a particular element.

ALGORITHM:

STEP1: Start the program.

STEP2: Declare the variable.

STEP3: Enter the size of the array and enter the elements one by one.

STEP4: Display the array elements before inserting.

STEP5: Inserting a new item between 0 to n positions.

STEP6: Display the array elements after inserting.

STEP7: Enter the position to delete between 0 to n elements.

STEP8: Display the array elements after performing the deletion operations

STEP9: Stop the program.

PROGRAM:

#include<stdio.h>

#include<conio.h>

void main()

int a[20],i,n,k,item;

clrscr();

printf(“Enter the size n of the array \n”);

scanf(“%d”,&n);

printf(“Enter the elements one by one \n”);

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

scanf(“%d”,&a[i]);

printf(“The array elements before inserting a new is \n”);

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

printf(“%d\n”,a[i]);

printf(“\n Enter the item to insert \n”);

scanf(“%d”,&item);

printf(“Enter the position to insert between 0 and n \n”);

scanf(“%d”,&k);

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

a[i+1]=a[i];

a[k]=item;

n=n+1;

printf(“The array elements after inserting a new elements is \n”);

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

printf(“%d\n”,a[i]);

getch();

}
PROGRAM:

#include<stdio.h>

#include<conio.h>

void main()

int a[20],i,n,k,item;

clrscr();

printf(“Enter the size n of the array \n”);

scanf(“%d”,&n);

printf(“Enter the elements one by one \n”);

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

scanf(“%d”,&a[i]);

printf(“The array elements before deleting an element is \n”);

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

printf(“%d\n”,a[i]);

printf(“Enter the position to delete between 0 and (n-1) \n”);

scanf(“%d”,&k);

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

a[i]=a[i+1];

n=n-1;

printf(“The array elements is \n”);

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

printf(“%d\n”,a[i]);

getch();

}
OUTPUT:

RESULT:

Thus the above program was executed successfully.

EX NO 2: IMPLEMENTATION OF ARRAY USING ROWMAJOR, COLUMNMAJOR ORDER

AIM:

To implement an array using row major, column major order.

ALGORITHM:

STEP1: Start the program.

STEP2: Declare the variable.

STEP3: Enter the number of row and column in an array.

STEP4: Enter the data one by one.

STEP5: Performing the operations and display the row major order.

STEP6: Display the column major order elements

STEP7: Stop the program.

PROGRAM:

#include<stdio.h>

#include<conio.h>

void main()

int a[20][20],m,n,i,j;

clrscr();

printf(“Give the number of row value \n”);

scanf(“%d”,&m);

printf(“Give the number of column value \n”);

scanf(“%d”,&n);

printf(“Give the value one by one \n”);

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

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

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

printf(“ROWMAJOR \n”);

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

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

printf(“%d\t”,a[i][j]);
printf(“\n”);

printf(“COLUMNMAJOR \n”);

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

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

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

printf(“\n”);

getch();

OUTPUT:

RESULT:

Thus the above program was executed successfully.

EX NO 3: CREATE A TWO DIMENSIONAL ARRAY WITH 10 ELEMENTS & SEARCH A

PARTICULAR ELEMENT PRINT POSITION & ADDRESS
AIM:

To write a C program to create a two dimensional array with 10 elements and search a
particular element.

ALGORITHM:

STEP1: Start the program.

STEP2: Declare the variables.

STEP3: Enter the number of row and column.

STEP4: Enter the data one by one in row wise.

STEP5: Enter the element to be search.

STEP6: Display the position and address of the searched item.

STEP7: Display the error message if the search item is not present.

STEP8: Stop the program.

PROGRAM:

#include<stdio.h>

#include<conio.h>

void main()

int a[20][20],i,j,m,n,item;

char F;

int *p=&a[0][0];

clrscr();

printf(“Enter the number of row \n”);

scanf(“%d”,&m);

printf(“Enter the number of column \n”);

scanf(“%d”,&n);
printf(“Enter the data one by one in rowwise \n”);

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

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

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

printf(“Enter the search item \n”);

scanf(“%d”,&item);

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

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

if(a[i][j]==item)

p=p+(i*n+j)+16;

F=’Y’;

printf(“The search item %d is the position %d %d”,item,i,j);

printf(“\n”);

printf(“\n The address of the search item %d is %d”,item,p);

break;

if(F!=’Y’)

printf(“\n The search item %d is not present in the array”,item);

getch();

}
OUTPUT:

RESULT:

Thus the above program was executed successfully.

Ex no 4: perform the push and pop operations in a stack using array

AIM:

To perform the push and pop operations in a stack using array.

ALGORITHM:

STEP1: Start the program.

STEP2: Declare the variable and initialize the top=-1

STEP3: Display the menu for variable function in a stack

STEP4: Enter any one of the option in a menu bar

STEP5: Using switch statement performing the operations in various cases

STEP6: Display the result of the each case for every operations

STEP7: Stop the program.

PROGRAM:

#include<stdio.h>

#include<conio.h>

int stack[100],choice,n;

int top=-1;
int x,i;

void push();

void pop();

void display();

void main()

clrscr();

printf("Enter the size of STACK [MAX=100]:");

scanf("%d",&n);

printf("STACK OPERATIONS USING ARRAY");

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

printf("\n 1.push\n 2.pop\n 3.display\n 4.exit\n");

do

printf("Enter the choice \n");

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

switch(choice)

case 1:

push();

printf("\n");

break;

case 2:
{

pop();

printf("\n");

break;

case 3:

display();

printf("\n");

break;

case 4:

printf("\n EXIT POINT");

break;

default:

printf("\n Please enter a valid choice (1/2/3/4)");

getch();

while(choice!=4);

}
void push()

if(top>=n-1)

printf("\n\t Stack is overflow");

getch();

else

printf("Enter the value to be pushed:");

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

top++;

stack[top]=x;

void pop()

if(top<=-1)

printf("\n\t stack is underflow");

else

printf("The popped elements is %d",stack[top]);

top--;
}

void display()

if(top>=0)

printf("\n The elements in STACK");

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

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

printf("\n Press next choice");

else

printf("\n The stack is empty");

OUTPUT:
RESULT:

Thus the above program was executed successfully.

Ex no 5: display the reverse of a string using stack

AIM:

To display the reverse of a string using stack.

ALGORITHM:

STEP1: Start the program.

STEP2: Declare the variable and functions used in the program.

STEP3: Getting the string from the input statements.

STEP4: Calculate the length of the string and to perform a reversing the given string by using
stack with various functions used in the stack conditions.

STEP5: Display the reverse of the given strings.

STEP6: Stop the program.

PROGRAM:

#include<stdio.h>

#include<conio.h>

#include<string.h>

#define MAX 20

int element;

int top=-1;

char stack_array[MAX];

void push(char element);

int isempty();

int isfull();

char pop();

void main()

{
char stack_string[30];

int count;

clrscr();

printf(“Enter the string \n”);

scanf(“%s”,stack_string);

for(count=0;count<strlen(stack_string);count++)

push(stack_string[count]);

for(count=0;count<strlen(stack_string);count++)

stack_string[count]=pop();

printf(“%s”,stack_string);

printf(“\n”);

getch();

void push(char element)

if(isfull())

printf(“\n stack overflow \n”);

else

{
top=top+1;

stack_array [top]=element;

char pop()

if(isempty())

printf(“\n stack underflow \n”);

return 1;

else

element=stack_array[top];

top=top-1;

return element;

int isempty()

if(top==-1)

return 1;

else

return 0;

}
int isfull()

if(top==MAX-1)

return 1;

else

return 0;

OUTPUT:

RESULT:

Thus the above program was executed successfully.

EX NO 6: evaluation of postfix expression

AIM:

To write a C program for evaluation of postfix expression

ALGORITHM:

STEP1: Start the program.

STEP2: Include the header file ctype.h

STEP3: declare the variables

STEP4: defining the functions for the name of push

STEP5: in main functions entering the statements

STEP6: using switch statements performing various cases

STEP7: getting the postfix expression and display the evaluation of the given expression
STEP8: Stop the program

PROGRAM:

#define SIZE 50

#include<stdio.h>

#include<conio.h>

#include<ctype.h>

int s[SIZE];

int top=-1;

push(int elem)

s[++top]=elem;

return 0;

int pop()

return(s[top--]);

void main()

char postfix[50],ch;

int i=0,op1,op2;

clrscr();

printf(“Read the postfix expression \n”);

scanf(“%s”,postfix);

while((ch=postfix[i++])!=’\0’)
{

if(isdigit(ch))

push(ch-‘0’);

else

{
op2=pop();

op1=pop();

switch(ch)

case ‘+’:

push(op1+op2);

break;

case ‘-’:

push(op1-op2);

break;

case ‘*’:

push(op1*op2);

break;

case ‘/’:

push(op1/op2);

break;

printf(“\n Give postfix expression:%s\n”,potfix);

printf(“\n Result after evaluation is %d \n”,s[top]);

getch();

OUTPUT:

RESULT:

Thus the above program was executed successfully.

EX NO 7: create a queue containing ten elements and perform an insert,

delete operations using array

AIM:

To write a C program for create a queue containing ten elements and perform an insert, delete
operations using array.

ALGORITHM:

STEP1: Start the program.

STEP2: create a structure for a name of queue and declaring an members of a queue.

STEP3: in main functions declare the structure variables and accessing a structure members

STEP4: entering the various statements for create insert, list, delete, exit.

STEP5: using switch statements performing the various case

STEP6: each cases performing the different operations

STEP7: display the result for the each case

STEP8: Stop the program

PROGRAM:
#include<stdio.h>

#include<conio.h>

struct queue

int data[50];

int front;

int rear;

};

void main()

int i,x,opt,item;

struct queue q;

q.front=-1;

q.rear=-1;

clrscr();

do

printf(“Select any one option \n”);

printf(“1.create \n”);

printf(“2.list \n”);

printf(“3.insert \n”);

printf(“4.delete \n”);

printf(“5.exit \n”);

scanf(“%d”,&opt);

switch(opt)
{

case 1:

printf(“Enter 10 data one by one \n”);

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

scanf(“%d”,&q.data[++q.rear]);

break;

case 2:

printf(“\n the data in the queue are \n”);

for(i=q.front+1;i<=q.rear;i++)

printf(“%d\n”,q.data[i]);

break;

case 3:

printf(“\n Enter the data to insert \n”);

scanf(“%d”,&item);

q.data[++q.rear]=item;

break;

case 4:

q.front++;

x=q.data[q.front];

printf(“\n The deleted item is \t%d\n”,x);

break;

}while(opt!=5);

getch();

}
OUTPUT:
RESULT:

Thus the above program was executed successfully.

EX NO 8: implementation of recursive function

AIM:

To write a C program implement a recursive function.

ALGORITHM:

STEP1: Start the program.

STEP2: in a main function to create a function name as fact

STEP3: declare the variables and get the values for the factorial variables

STEP4: call the function using function name fact

STEP5: in function definition using recursive function to calculate the factorial value for a given
value

STEP6: return the value and print them in main function

STEP7: Stop the program

PROGRAM:

#include<stdio.h>
#include<conio.h>

main()

int fact(int);

int n,f;

clrscr();

printf(“Give the value of n \n”);

scanf(“%d”,&n);

f=fact(n);

printf(“Factorial of the given number is %d”,f);

getch();

return 0;

int fact(int n)

if(n==0)

return 1;

else

return (n*fact(n-1);

OUTPUT:
RESULT:

Thus the above program was executed successfully.

EX NO 9: to create a singly linked list containing at least five elements

AIM:

To creating a singly linked list containing at least five elements with more necessary
assumption.

ALGORITHM:

STEP1: Start the program.

STEP2: creating the structure to assigning the members within the structure

STEP3: in main function declare and assigning the values to the variables

STEP4: using the function statements getting the data.

STEP5: calculate the status and total no of nodes in the list

STEP6: to display the result

STEP7: Stop the program

PROGRAM:

#include<stdio.h>

#include<malloc.h>

#include<stdlib.h>

void main()

struct node

int num;

struct node*ptr;

};
typedef struct node NODE;

NODE *head,*first,*temp=0;

int count=0;

int choice=1;

first=0;

while(choice)

head=(NODE*)malloc(sizeof(NODE));

printf(“Enter the data item \n”);

scanf(“%d”,head->num);

if(first!=0)

temp->ptr=head;

temp=head;

else

first=temp=head;

fflush(stdin);

printf(“Do you want to continue(Type 0 or 1)? \n”);

scan(“%d”,&coice);

temp->ptr=0;

/*reset temp to the beginning */

temp=first;

printf(“\n Status of the linked list is \n”);

while(temp!=0)

printf(“%d=>”,temp->num);

count++;

temp=temp->ptr;

printf(“null \n”);

printf(“no.of nodes in the list =%d\n”,count);

getch();

OUTPUT:

RESULT:

Thus the program was executed successfully.

EX NO 10: to delete the first node from the singly linked list

AIM:

To delete the first node that contains an integer data item of a singly linked list

ALGORITHM:

STEP1: Start the program.

STEP2: using the structure and user defined functions to the program

STEP3: in main function declare the variable and assign the values

STEP4: getting no of nodes and each nod from the user.

STEP5: using delete function to delete a first node from the list

STEP6: using display function to display the elements in the list

STEP7: Stop the program

PROGRAM:

#include<stdio.h>

#include<conio.h>

#include<malloc.h>

typedef struct nodetype

int info;

struct nodetype *next;

}node;

void createlist(node**,int);

void deleteatbeg(node**);

void display(node*);

void main()

{
node *start;

int item,n,i;

start=NULL;

clrscr();

printf(“Enter no of nodes:\n”);

scanf(“%d”,&n);

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

printf(“Item for node %d:\n”i+1);

scanf(“%d”,&item);

createlist(&start,item);

printf(“The list is:\n”);

display(start);

printf(“\n press any key to delete first node \n”);

getch();

deleteatbeg(&start);

printf(“\n the list after deletion at first is \n”);

display(start);

getch();

void createlist(node**start,int item)

node *ptr,*last;

ptr=(node*)malloc(sizeof(node));
ptr->info=item;

ptr->next=NULL;

if(*start==NULL)

*start=ptr;

else

last=*start;

while(last->next!=NULL)

last=last=>next;

last->next=ptr;

void deleteatbeg(node*start)

node*ptr;

int temp;

ptr=*start;

temp=ptr->info;

*start=ptr->next;

free(ptr);

printf(“\n deleted item is %d=\n”,temp);

void display(node*start)
{

int n=0;

while(start!=NULL)

printf(“\t %d”,start->info);

n++;

start=start->next;

printf(“\n total number of nodes are:%d”,n);

OUTPUT:

RESULT:

Thus the program was executed successfully.

EX NO 11: binary tree creation

AIM:

To write a C program for implementation of binary tree creation.

ALGORITHM:
STEP1: Start the program.

STEP2: declare the variables

STEP3: using the structure and assigning the values to the variables

STEP4: using the switch case statements for various functions insert,create()

STEP5: defining the above functions for the given functions declarations

STEP6: display the result

STEP7: Stop the program

PROGRAM:

#include<stdio.h>

#include<conio.h>

struct node

int value;

struct node *l,*L;

struct node *y;

}*root=NULL,*temp=NULL;

void insert();

void create();

int flag=1;

void main()

int ch;

clrscr();

printf("\n operation--");

printf("\n 1.insert an element into tree \n");

printf("\n 2.create \n");

printf("\n 3.exit \n");

while(1)

printf("\n Enter your choice:");

scanf("%d",&ch);

switch(ch)

case 1:

insert();

break;

case 2:

create();

break;

case 3:

exit(0);

default:

printf("k choice,please enter correct choice");

break;

void insert()

int data;
printf("Enter data of node to be inserted:");

scanf("%d",&data);

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

temp->value=data;

temp->l=temp->L=NULL;

void create()

create();

if(root==NULL)

root=temp;

getch();

OUTPUT:
RESULT:

Thus the program was executed successfully.

EX NO 12: preorder traversal of binary tree

AIM:

To write a C program for implementation of preorder traversal of binary tree.

ALGORITHM:

STEP1: Start the program.

STEP2: defining a structure node and declaring the structure members

STEP3: to assigning the values for the structure members

STEP4: In main function using if else statements to insert a data on left and right side of the tree

STEP5: call the pre order function to arrange the tree elements in preorder

STEP6: Stop the program

PROGRAM:

#include<stdio.h>

struct tnode

int data;

struct tnode*right;

struct tnode*left;

};

struct tnode *CreateBST(struct tnode*,int);

void preorder(struct tnode*);

int main()

struct tnode *root=NULL;

int choice,item,n,i;

clrscr();

do

printf("\n Binary search tree operations");

printf("\n 1.Creation of BST");

printf("\n 2.Traverse in preorder");

printf("\n 3.exit");

printf("\n Enter choice:");

scanf("%d",&choice);

switch(choice)

case 1:

root=NULL;

printf("\n Binary Search Tree for How many nodes?\n");

scanf("%d",&n);

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

printf("Enter data for node %d:",i);

scanf("%d",&item);

root=CreateBST(root,item);

printf("\n Binary Search Tree with %d nodes is ready to use!!\n",n);

break;

case 2:
printf("\n Binary Search Tree traversal in preorder \n");

preorder(root);

break;

case 3:

printf("\n Terminating \n");

break;

default:

printf("\n\n invalid option!!! try again!!\n\n");

break;

}while(choice!=3);

return 0;

struct tnode *CreateBST(struct tnode *root,int item)

if(root==NULL)

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

root->left=root->right=NULL;

root->data=item;

return root;

else

if(item<root->data)
root->left=CreateBST(root->left,item);

else if(item>root->data)

root->right=CreateBST(root->right,item);

else

printf("Duplicate Element !! not allowed!!! ");

return (root);

void preorder(struct tnode*root)

if(root!=NULL)

printf("%d",root->data);

preorder(root->left);

preorder(root->right);

getch();

OUTPUT:
RESULT:

Thus the program was executed successfully.

EX NO 13: binary search

AIM:

To perform in a C program for implementation of binary searching.

ALGORITHM:

STEP1: Start the program.

STEP2: declare the variables

STEP3: get the elements one by one using array

STEP4: enter the element for the search

STEP5: using the statements to find the searching elements in the array

STEP6: if the element is present print the position of the element

STEP7: otherwise to print the statement as search failed

STEP8: Stop the program

PROGRAM:

#include<stdio.h>

#include<conio.h>

void main()

int lb,ub,a[10],mid,x,n,i,j,k;

clrscr();

printf(“Enter the maximum number of elements \n”);

scanf(“%d”,&n);

printf(“Enter the elements one by one \n”);

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

scanf(“%d”,&a[i]);

printf(“Enter the elements to search \n”);

scanf(“%d”,&x);

lb=0;

ub=n-1;

while(lb<=ub)

mid=(lb+ub)/2;

if(a[mid]==x)

printf(“The element is present at %d position”,mid);

break;

}
else

if(a[mid]>k)

ub=mid-1;

else

lb=mid+1;

if(lb>ub)

printf(“\n Search Failed”);

getch();

OUTPUT:

RESULT:

Thus the program was executed successfully.

EX NO 14: insertion sort

AIM:

To write a C program for implementation of insertion sort.

ALGORITHM:

STEP1: Start the program.

STEP2: declaring the variables

STEP3: get the number of elements and getting the each element using array

STEP4: using while loop statements and comparing the variables to sort the given elements

STEP5: using the statements to find the searching elements in the array

STEP6: Stop the program

PROGRAM:

#include<stdio.h>

#include<conio.h>

void main()

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

clrscr();

printf(“Insertion Sort \n”);

printf(“Give the number of elements \n”);

scanf(“%d”,&n);

printf(“Give the elements one by one \n”);

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

scanf(“%d”,&a[i]);

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

k=a[i];

j=i-1;

a[j+1]=k;

printf(“The Sorted list \n”);

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

printf(“%d\t”,a[i]);

getch();

OUTPUT:

RESULT:

Thus the program was executed successfully.

EX NO 15: bubble sort

AIM:

To write a C program for implementation of bubble sort.

ALGORITHM:

STEP1: Start the program.

STEP2: declare the variables

STEP3: using for loop and scanf function getting elements one by one

STEP4: using for loop statements to found the scan and compare the data

STEP5: using if statement to compare and sort the elements

STEP6: to print the sorted list of elements from an array

STEP7: Stop the program

PROGRAM:
#include<stdio.h>

#include<conio.h>

void main()

int i,j,n,a[20],temp;

clrscr();

printf(“Bubble Sort \n”);

printf(“Give the number of data \n”);

scanf(“%d”,&n);

printf(“Give the data one by one \n”);

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

scanf(“%d”,&a[i]);

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

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

if(a[j]>a[j+1])

temp=a[i];

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

a[j+1]=temp;

printf(“The Sorted list \n”);

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

printf(“%d\t”,a[i]);
getch();

OUTPUT:

RESULT:

Thus the above program was executed successfully.

EX NO 16: selection sort

AIM:

To write a C program for implementation of selection sort.

ALGORITHM:

STEP1: Start the program.

STEP2: declaring the variables

STEP3: get the n number of elements from an array

STEP4: using for loop statements and if conditions to perform in the selection operation

STEP5: to display in the sorted list of elements

STEP6: Stop the program

PROGRAM:

#include<stdio.h>

#include<conio.h>
void main()

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

clrscr();

printf(“Selection Sort \n”);

printf(“Give the number of data \n”);

scanf(“%d”,&n);

printf(“Give the elements one by one \n”);

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

scanf(“%d”,&a[i]);

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

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

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

k=a[i];

a[i]=a[j];

a[j]=k;

printf(“The Sorted list \n”);

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

printf(“%d\t”,a[i]);

getch();

}
OUTPUT:

RESULT:

Thus the above program was executed successfully.