ARRAY OPERATIONS

PROGRAM:

#include<stdio.h>
#include<conio.h>
#define SIZE 100

void display(int arr[],int n)

int i;

if(n==0)

Printf(“Array is empty!\n”);
return;

printf(“Array:”);
for(i=0;i<n;i++)

printf(“%d”,arr[i]);

printf(“\n”);

int insert(int arr[],int n,int pos,int val)

int i;

if(n==SIZE)

printf(“Array is full!\n”);

return n;

}
for(i=n;i>pos;i--)

arr[i]=arr[i-1];

arr[pos]=val;

return n+1;

int delete(int arr[ ],int n,int pos)

int i;

if(n==0)

printf(“Array is empty!\n”);

return n;

if(pos<0||pos>=n)

printf(“Invalid position!\n”);

return n;

for(i=pos;i<n1;i++)

arr[i]= arr[i+1];

return n-1;

int main()

int arr[SIZE],n=0,choice,pos,val;
while(1)

printf(“\n1.Insert\n2.Delete\n3.Display\n4.Exit\n”);

printf(“Enter your choice:”);

 scanf(“%d”,&choice);switch(choice)

case1:

printf(“Enter position(0to%d)and value:”,n);

scanf(“%d %d”, &pos, &val);

n=insert(arr,n,pos,val); break;

case2:

printf(“Enter position(0to%d)to delete:”,n-1)

scanf(“%d”, &pos);

n=delete(arr,n,pos);

break;

case3:

display(arr,n);

break;

case4:

return 0;

default:

printf(“Invalid choice!\n”);

getch();

return 0;

}
OUTPUT:

1. Insert

2. Delete

3. Display

4. Exit

Enter your choice:1

Enter position(0to0)and value:01

1. Insert

2. Delete

3. Display

4. Exit

Enter your choice:1

Enter position(0to1)and value:12

1. Insert

2. Delete

3. Display

4. Exit

Enter your choice:1

Enter position(0to2)and value:23

1. Insert

2. Delete

3. Display

4. Exit

Enter your choice:1

Enter position(0to3)and value:34

1. Insert
2. Delete

3. Display

4. Exit

Enter your choice:3

Array: 1234

1. Insert

2. Delete

3. Display

4. Exit

Enter your choice:2

Enter position(0to3)to delete:1

1. Insert

2. Delete

3. Display

4. Exit

Enter your choice:3

Array : 134

1. Insert

2. Delete

3. Display

4. Exit

Enter your choice:4

 RUNNING TIME COMPLEXITY

PROGRAM:

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

void algorithm(int n)

int i, j;
clrscr();

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

printf(“%d“,i);

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

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

printf(“%d“,i*j);

int main()

const int n=5;

clock_tstart,end;

double executiontime;

start= clock();
algorithm(n);

end=clock();

execution time=(double)(end-start)/CLOCKS_PER_SEC;

printf(“\nexecutiontime:%f seconds\n”, executiontime);

printf(“time complexity: o(n^2)\n”);

getch();
return 0;

}
OUTPUT:

012340000001234024680369120481216

Executiontime:0.000000seconds
timecomplexity: o(n^2)
 INFIX TO POSTFIX USING STACK

PROGRAM:

#include<stdio.h>
#include<conio.h>
#include<ctype.h>
char stack[100];
int top = -1;

void push(char x)

stack[++top]=x;

char pop( )

if(top==-1)

return -1;

else

return stack[top--];

int priority(char x)

if(x==’(‘)

return 0;

if(x==’+’||x==’-‘)
return 1;

if(x==‘x’||x==’/’)
return 2;

return 0;

int main( )
{

char exp[100];

char *e,x;

printf(“Enter the expression:”);

scanf(“%s”,exp);

e=exp;
while(*e!=’\0’)

if(isalnum(*e))

printf(“%c”,*e);

else if(*e==’(‘)
push(*e);

else if(*e==’)’)

while((x=pop())!=’(‘)
printf(“%c”,x);

else

while(priority(stack[top])>=priority(*e))
printf(“%c”,pop());

push(*e);

else

while(priority(stack[top])>=priority(*e))

printf(“%c”,pop());

push(*e);

} e++;
 }

while(top!= -1) printf(“%c”,pop());

getch();

return 0;
OUTPUT:

Enter the expression:a+b*c-

d abc*+d-
 CIRCULAR QUEUE OPERATIONS

PROGRAM:

#include<stdio.h>

#include<conio.h>

#define MAX 5

int queue[MAX];

int front = -1, rear = -1;

void enqueue(int value)

clrscr();

if(rear = = MAX-1)

printf(“Queue is full\n”);

else if(front==-1)

front = 0;

rear=0;

queue[rear]=value;

else

rear=(rear+1)%MAX;
queue[rear]=value;

void enqueue( )

{
 if (front == -1)

printf(“Queue is empty\n”);

else

printf(“Dequeued:%d\n”,queue[front]);

front = (front + 1) % Max;

void printQueue( )

if(front==-1)

printf(“Queue is empty\n”);

else

int temp=front;
while(temp!=rear){

printf(“%d”, queue[temp]);

temp=(temp+1) % MAX;

printf(“d\n”,queue[rear]);

}
int main( )

enqueue(1);
enqueue(2);
enqueue(3);
printQueue();
dequeue();
printQueue();

getch();

return 0;

}
OUTPUT:

123

Dequeued:1

23
 POLYNOMIAL MANIPULATION USING SINGLE LINKED LIST

PROGRAM:

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

#include<iostream.h>

struct Node

int coeff,exp;
Node* next;
Node*nullptr;

Node(intc,inte):coeff(c),exp(e),next(nullptr){}

};

void insert(Node*&head,intc,inte){
clrscr();

Node* newNode=new Node(c,e);

if(!head || head -> exp<e) {

newNode->next=head;
head=newNodee;

else

Node*temp=head;

while(temp ->next && temp->next-> exp>e)temp=temp->next;

if(temp->exp==e)

temp->coeff+=c;

else

newNode->next=temp>next;
 temp->next = newNode;

Node*nullptr
;

Node*next;

Node*addPoly(Node*p1,Node*p2)

Node*result=nullptr;

while(p1 || p2)

if(!p2||(p1&&p1->exp>p2->exp))

insert(result,p1->coeff,p1->exp),p1=p1=next;

else if(!p1 || (p2 && p2 ->exp>p1->exp)){

insert(result,p2->coeff,p2->exp),p2=p2->next;

else

insert(result,p1->coeff+p2->coeff,p1->exp);

p1 = p>next, p2=p2->next;

return result;

void printpoly(Node*head)
{

while(head) {

cout<<head->coeff<<”x”<<head->exp;

if(head->next)cout<<”+”;

head=head->next;

cout<<endl;

int main()

Node*poly1=nullptr,*poly2=nullptr;

insert(poly1,3,2),insert(poly1,5,1),insert(poly1,4,3);

insert(poly2,2,2),insert(poly2,3,1),insert(poly2,3,3);
Node*result=addPoly(poly1,poly2);

cout<<”Resultant Polynomial:”);

printPoly(result);

getch();
return 0;

}
OUTPUT:

Resultant Polynomial:7x3+5x2+8x1
 VARIOUS OPERATIONS IN DOUBLE LINKED LIST

PROGRAM:

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

type def struct Node;

int data;

struct Node*prev,*next;

Node;

Node*createNode(int data)

Node* newNode=(Node*)malloc(sizeof(Node));

clrscr();

newNode->data=data;

newNode->prev=newNode->next=NULL;
return newNode;

void insertFront(Node**head, int data)

Node*newNode createNode(data);
newNode->next=*head; if(*head)
(*head)->prev=newNode;

*head=newNode;

void insertEnd(Node** head, int data)

{
 Node*newNode=createNode(data);
Node* temp;

if(!*head)

*head=newNode;
return ;

temp=*head;
while(temp->next) temp= temp->next; temp->next =newNode;
newNode->prev=temp;

void deleteNode(Node**head, int key)

Node* temp= *head;

while(temp&&temp->data!=key)temp=temp->next;

if(! temp) return;

if(temp->prev) temp->prev->next = temp->next;

else *head= temp->next;

if(temp->next)temp->next->prev=temp->prev;
free(temp);

void display(Node*head)

while(head)

printf(“%d”, head->data);
head= head->next;

printf(“\n”);

}
int main( )

Node* head = NULL;

insertFront(&head,30);

insertFront(&head,20);

insertFront(&head,10);

insertEnd(&head,40);

display(head);

deleteNode(&head,20);

display(head);

getch();

return 0;

}
OUTPUT:

10203040

103040
 PERFORM BINARY SEARCH

PROGRAM:

#include<stdio.h>
#include<conio.h>
void main( )

int n, i, search,f=0,low,high,mid,a[20];
clrscr();

printf(“Enter the n value:”);

scanf(“%d”, &n);

printf(“Enter the numbers in ascending order:\n”);

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

printf(“a[%d]:“,i);

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

printf(“Enter the search element:”);

scanf(“%d”, &search);

low=0;
high=n1;

while(low<=high)

mid=(low+high)/2;

if(search<a[mid])

high=mid-1;

else if(search>a[mid])

{
 Low=mid+1;

else

f=1;

printf(“Element found at position:%d\n”,mid+1);

break;

if(f==0)

printf(“Element not present in the array.\n”);

getch( );

}
OUTPUT:

Enter the n value:5

Enter the numbers in ascending order:

A[0]: 2

A[1]:4

A[2]:6

A[3]:9

A[4]:12

Enter the search element : 4

Element found at position:2
COMPARE AMONG BUBBLE SORT,SELECTION SORT AND INSERTIONSORT

PROGRAM:

#include<stdio.h>

#include<conio.h>

Void bubblesort(int arrr[],int n)

int i,j,temp;
clrscr();

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

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

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

temp=arr[j];

arr[j]=arr[j+1];

arr[j+1]=temp;

void selectionsort(int arr[],int n)

int i, j, temp;

clrscr();

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

{
int minIndex = i;

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

if(arr[j]<arr[minIndex])

minIndex=j;

temp=arr[minIndex];

arr[minIndex]=arr[i];

void insertionsort(int arr[],int n)

int i, j, key;

clrscr();

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

key=arr[i];

j=i-1;

while(j>=0&&arr[j]>key)

arr[j+1]=arr[j];

j--;

arr[j+1]=key;

}
void printarray(int arr[],int n)

int i;

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

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

int main( )

int n,i,choice;
int arr[100];

printf(“Enter the number of elements:”);

scanf(“%d”, &n);

printf(“Enter the elements:\n”);

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

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

printf(“choose sorting algorithm1.bubble2.insertion3.selection”);

scanf(“%d”, &choice);

if(choice ==1)

bubblesort(arr, n);

else if(choice==2)

insertionsort(arr,n);

else if(choice==3)

selectionsort(arr, n);

else

printf(“Invalid choice!\n”);

return 1;
 }

printf(“Sorted array:”);

print array(arr, n);

getch( );

return 0;

}
OUTPUT:

Enter the number of elements:

Choose sorting algorithm1.bubble2.insertion3.selection

Sorted array:
1

6
 DELETION IN BINARY SEARCH TREE

PROGRAM:

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
struct Node

int data;

struct Node*left,*right;

};

struct Node*newNode(int data){

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

clrscr();

temp->data=data;

temp->left=temp>right=NULL;
return temp;

struct Node*findMin(struct Node*root)

while(root>left)root=root->left;

return root;

struct Node*deleteNode(struct Node*root,int key)

if(!root)

return NULL;

if(key<root->data)

root->left=deleteNode((root->left,key);
 else if(key>root->data)

root->right=deleteNode(root->right, key);

else

struct Node*temp;

if(!root->left)

return root->right;

if(!root->right)

return root->left;

temp=findMin(root->right);

root->data=temp->data;

root->right=deleteNode(root->right,temp->data);

return root;

void inorder(struct Node*root)

if(root)

inorder(root->left);

printf(“%d “,root->data);
inorder(root->right);

struct Node*insert(struct Node*root,int data)

if(root)
 return newNode(data);

if(data<root->data)

root->left=insert(root->left,data);

else

root->right=insert(root->right,data);

return root;

int main( )

struct Node* root=NULL;

root=insert(root,50);

root=insert(root,30);

root=insert(root,70);
printf(“Before Deletion:”);
inorder(root);

printf(“\n”);
root=deleteNode(root,50);
printf(“After Deletion:”);
inorder(root);
printf(“\n”);
getch();
return 0;

}
OUTPUT:

BeforeDeletion:305070

AfterDeletion:3070
 GRAPH TRAVERSALS

PROGRAM:

#include<stdio.h>
#include<conio.h>
#define MAX 10

int graph[MAX][MAX],
visited[MAX],n; int i;

void dfs(int v)

printf(“%d ”,v);
visited[v]=1;
for(i=0;i<n;i++)

if(graph[v][i] &&!visited[i])

dfs(i);

void bfs(int start)

int front=0;rear=0;
int i;
visited[start]=1;
queue[rear++]=start;
while(front<rear)
{

int v==queue[front++];
printf(“%d ”,v);
for(i=0; i<n; i++)

if(graph[v][i]&&!visited[i])

visited[i]=1;
queue[rear++]=i;

}
int main()
{

int edges,v1,v2,start;
int i;

scanf(“%d%d”,&n,&edges);
for(I=0; I<edges;I++)

scanf(“%d %d”, &v1, &v2);

graph[v1][v2]=graph[v2][v1]=1;

scanf((“%d”,&start);

printf(“DFS:”);
dfs(start);

for(i=0;i<n;i++)visited[I]=0;
printf(“\nBFS: “);

bfs(start);
getch();
return 0;

}
OUTPUT:

56

01

02

13

14

23

34

DFS:0132

BFS:01234