//Program 1

//WAP to perform linear search

#include<stdio.h>
#include<conio.h>
void main()
{
int a[20],i,key,f=0,size;
clrscr();
printf("Enter number of elements:");
scanf("%d",&size);
printf("Enter elements\n");
for(i=0;i<size;i++)
scanf("%d",&a[i]);
printf("Enter element to be searched:");
scanf("%d",&key);
for(i=0;i<size;i++)
{
if(a[i]==key)
{
f=1;
break;
}
}
if(f==0)
printf("No such number found");
else
printf("Number is found at index:%d",i+1);
getch();
}
======================================================
//Program 2
//WAP to perform binary search
#include<stdio.h>
#include<conio.h>
int binary_search(int arr[],int,int);
void main()
{
int arr[20],i,size,key,f;
clrscr();
printf("Enter number of elements:");
scanf("%d",&size);
printf("Enter elements in ascending order\n");
for(i=0;i<size;i++)
scanf("%d",&arr[i]);
printf("Enter number to be searched:");
scanf("%d",&key);
f=binary_search(arr,size,key);
if(f==0)
printf("No such number is found");
else
printf("Number is found at index=%d",f+1);
getch();
}
int binary_search(int arr[],int size,int key)
{

int first,last,mid;
first=0;
last=size-1;
while(first<=last)
{
mid=(first+last)/2;
if(arr[mid]==key)
return(mid);
else if(arr[mid]<key)
first=mid+1;
else
last=mid-1;
}
return(0);
}
======================================================
//program 3
//WAP to reverse a string
#include<stdio.h>
#include<conio.h>
void main()
{
int i,j,len=0;
char str[25],temp;
clrscr();
printf("Enter a string\n");
gets(str);
while(str[len]!='\0')
{
len++;
}
for(i=0,j=len-1;i<len/2;i++,j--)
{
temp=str[i];
str[i]=str[j];
str[j]=temp;
}
printf("Reverse of string is\n");
puts(str);
getch();
}
=======================================================
//Program 4
//WAP to create a linked list and perform
//insertion & deletion at given location
#include<stdio.h>
#include<conio.h>
typedef struct node
{
int data;
struct node *next;
}node;
node *create(int);

node *insert_loc(node *,int,int);

node *delete_loc(node *,int);
void print(node *);
void main()
{
int n,loc1,loc2,num;
node *HEAD;
clrscr();
printf("Enter number of elements to be insert:");
scanf("%d",&n);
printf("Enter elements\n");
HEAD=create(n);
printf("The list is\n");
print(HEAD);
printf("\n\nEnter location at which element is to be inserted:");
scanf("%d",&loc1);
printf("Enter element:");
scanf("%d",&num);
HEAD=insert_loc(HEAD,loc1,num);
printf("After insertion the list is\n");
print(HEAD);
printf("\n\nEnter location at which element is to be deleted:");
scanf("%d",&loc2);
HEAD=delete_loc(HEAD,loc2);
printf("After deletion the list is\n");
print(HEAD);
getch();
}
node *create(int n)
{
int i;
node *head,*p;
head=(node*)malloc(sizeof(node));
head->next=NULL;
scanf("%d",&(head->data));
p=head;
for(i=1;i<n;i++)
{
p->next=(node*)malloc(sizeof(node));
p=p->next;
scanf("%d",&(p->data));
p->next=NULL;
}
return(head);
}
void print(node *p)
{
while(p!=NULL)
{
printf("%d\t",p->data);
p=p->next;
}
}
node *insert_loc(node *head,int loc,int x)
{
node *p,*q;
int i;
p=(node*)malloc(sizeof(node));
p->data=x;
p->next=NULL;

if(loc==1)
{
p->next=head;
return(p);
}
q=head;
for(i=1;i<loc-1;i++)
if(q!=NULL)
q=q->next;
else
{
printf("\nLocation not found");
return(head);
}
p->next=q->next;
q->next=p;
return(head);
}
node *delete_loc(node *head,int loc)
{
node *p,*q;
int i;
if(loc==1)
{
p=head;
head=head->next;
free(p);
return(head);
}
q=head;
for(i=1;i<loc-1;i++)
q=q->next;
if(q==NULL)
{
printf("\nUndeflow!!!");
return(head);
}
p=q->next;
q->next=p->next;
free(p);
return(head);
}
====================================================================
//Program5
//WAP to create a circular linked list and perform
//insertion and deletion at a given location
#include<stdio.h>
#include<conio.h>
typedef struct node
{
int data;
struct node *next;
}node;
node *create(node *,int);
node *insert_cir_loc(node *,int,int);
node *delete_cir_loc(node *,int);
void print(node *);
void main()

{
int i,x,n,loc1,loc2,num;
node *REAR;
clrscr();
REAR=NULL;
printf("Enter number of element:");
scanf("%d",&n);
printf("Enter elements\n");
for(i=0;i<n;i++)
{
scanf("%d",&x);
REAR=create(REAR,x);
}
printf("The list is\n");
print(REAR);
printf("\nEnter the location at which element is to be inserted:");
scanf("%d",&loc1);
printf("Enter element:");
scanf("%d",&num);
REAR=insert_cir_loc(REAR,loc1,num);
printf("List after insertion\n");
print(REAR);
printf("\nEnter the location at which element is to be deleted:");
scanf("%d",&loc2);
REAR=delete_cir_loc(REAR,loc2);
printf("List after deletion\n");
print(REAR);
getch();
}
node *create(node *rear,int x)
{
node *p;
p=(node*)malloc(sizeof(node));
p->data=x;
if(rear==NULL)
{
rear=p;
p->next=p;
return(p);
}
p->next=rear->next;
rear->next=p;
rear=p;
return(rear);
}
node *insert_cir_loc(node *rear,int loc,int x)
{
node *p,*q;
int i;
p=(node*)malloc(sizeof(node));
p->data=x;
p->next=NULL;
if(loc==1)
if(rear==NULL)
{
p->next=p;
return(p);
}
else
{

p->next=rear->next;
rear->next=p;
return(rear);
}
q=rear->next;
for(i=1;i<loc-1;i++)
if(q!=rear)
q=q->next;
else
{
printf("Location is not found");
return(rear);
}
p->next=q->next;
q->next=p;
return(rear);
}
node *delete_cir_loc(node *rear,int loc)
{
node *p,*q;
int i;
p=rear;
if(loc==1)
{
if(rear->next==rear)
{
free(p);
return(NULL);
}
else
{
p=rear->next;
rear->next=p->next;
free(p);
return(rear);
}
}
q=rear->next;
for(i=1;i<loc-1;i++)
if(q!=NULL)
q=q->next;
else
{
printf("\nLocation not found");
return(rear);
}
p=q->next;
q->next=p->next;
free(p);
return(rear);
}
void print(node *rear)
{
node *p;
if(rear!=NULL)
{
p=rear->next;
do
{

printf("%d\t",p->data);
p=p->next;
}while(p!=rear->next);
}
}
====================================================================
//Program 6
//WAP to create a doubly linked list & perform
//insertiom and deletion at given location
#include<stdio.h>
#include<conio.h>
typedef struct dnode
{
int data;
struct dnode *next,*prev;
}dnode;
dnode *create();
dnode *insert_loc(dnode *,int,int);
dnode *delete_loc(dnode *,int);
void print(dnode *);
void main()
{
dnode *HEAD;
int loc1,loc2,num;
clrscr();
HEAD=NULL;
HEAD=create();
printf("The list is\n");
print(HEAD);
printf("\nEnter the location at which element is to be inserted:");
scanf("%d",&loc1);
printf("Enter element:");
scanf("%d",&num);
HEAD=insert_loc(HEAD,loc1,num);
printf("\nList after insertion\n");
print(HEAD);
printf("\nEnter the location at which element is to be deleted:");
scanf("%d",&loc2);
HEAD=delete_loc(HEAD,loc2);
printf("\nList after deletion\n");
print(HEAD);
getch();
}
dnode *create()
{
dnode *p,*q,*h;
int i,n,x;
h=NULL;
printf("Enter no of elements:");
scanf("%d",&n);
printf("Enter elements\n");
for(i=0;i<n;i++)
{
scanf("%d",&x);
q=(dnode*)malloc(sizeof(dnode));
q->data=x;

q->prev=q->next=NULL;
if(h==NULL)
p=h=q;
else
p->next=q;
q->prev=p;
p=q;
}
return(h);
}
void print(dnode *head)
{
while(head!=NULL)
{
printf("%d\t",head->data);
head=head->next;
}
}
dnode *insert_loc(dnode *head,int loc,int x)
{
dnode *p,*q;
int i;
p=(dnode*)malloc(sizeof(dnode));
p->data=x;
p->next=p->prev=NULL;
if(loc==1)
{
if(head==NULL)
return(p);
else
{
p->next=head;
head->prev=p;
head=p;
return(head);
}
}
q=head;
for(i=1;i<loc-1;i++)
if(q!=NULL)
q=q->next;
else
{
printf("Location not found");
return(head);
}
p->next=q->next;
p->prev=q;
q->next->prev=p;
q->next=p;
return(head);
}
dnode *delete_loc(dnode *head,int loc)
{
dnode *p,*q;
int i;
if(loc==1)
{

if(head->next==NULL)
{
free(head);
return(NULL);
}
else
{
p=head;
p=p->next;
free(head);
return(p);
}
}
q=head;
for(i=1;i<loc-1;i++)
if(q!=NULL)
q=q->next;
else
{
printf("Location not found");
return(head);
}
p=q->next;
q->next=p->next;
p->next->prev=q;
return(head);
}
=============================================================
//Program 7
//WAP to create a circular doubly linked list
#include<stdio.h>
#include<conio.h>
typedef struct dnode
{
int data;
struct dnode *next,*prev;
}dnode;
dnode *create(dnode *,int);
void print(dnode *);
void main()
{
dnode *HEAD;
int i,x,n;
clrscr();
HEAD=NULL;
printf("Enter number of elements to be inserted:");
scanf("%d",&n);
printf("Enter elements\n");
for(i=0;i<n;i++)
{
scanf("%d",&x);
HEAD=create(HEAD,x);
}
printf("The list is\n");
print(HEAD);
getch();

}
dnode *create(dnode *head,int x)
{
dnode *p;
p=(dnode*)malloc(sizeof(dnode));
p->data=x;
p->prev=p->next=NULL;
if(head==NULL)
{
p->prev=p->next=p;
return(p);
}
p->prev=head->prev;
p->next=head;
head->prev->next=p;
head->prev=p;
return(head);
}
void print(dnode *head)
{
dnode *p;
p=head;
do
{
printf("%d\t",p->data);
p=p->next;
}while(p!=head);
}
===================================================================
//Program 8
//WAP to perform PUSH and POP operation on a stack array
#include<stdio.h>
#include<conio.h>
#define MAX 25
int a[MAX],top=-1;
void PUSH(int);
void POP();
void DISPLAY();
void main()
{
int x,ch,c;
clrscr();
do
{
printf("\n\tMENU\n");
printf("1:PUSH\n2:POP\n3:DISPLAY\n");
printf("\nEnter your chice:");
scanf("%d",&ch);
switch(ch)
{
case 1:printf("\nEnter number to be pushed:");
scanf("%d",&x);
PUSH(x);
break;
case 2:POP();
break;

case 3:DISPLAY();
break;
default :printf("\nInvalid chice!!!");
}
printf("\nDo you want to ga back to menu(1:YES/2:NO):");
scanf("%d",&c);
}while(c==1);
getch();
}
void PUSH(int x)
{
if(top==MAX-1)
printf("\nOverflow!!!");
else
{
top++;
a[top]=x;
}
}
void POP()
{
if(top==-1)
printf("\nUnderflow!!!");
else
{
printf("\nElement getting poped=%d",a[top]);
top--;
}
}
void DISPLAY()
{
int i;
printf("\nThe stack is\n");
for(i=top;i>=0;i--)
printf("%d\t",a[i]);
}
====================================================================
//Program 9
//WAP to create a linear queue with insert & delete function
#include<stdio.h>
#include<conio.h>
#define MAX 25
int a[MAX],front=-1,rear=-1;
void Insert(int);
void Delete();
void DISPLAY();
void main()
{
int x,ch,c;
clrscr();
do
{
printf("\n\tMENU\n");
printf("1:Insert\n2:Delete\n3:DISPLAY\n");
printf("\nEnter your chice:");
scanf("%d",&ch);
switch(ch)

{
case 1:printf("\nEnter number to be inserted:");
scanf("%d",&x);
Insert(x);
break;
case 2:Delete();
break;
case 3:DISPLAY();
break;
default :printf("\nInvalid chice!!!");
}
printf("\nDo you want to ga back to menu(1:YES/2:NO):");
scanf("%d",&c);
}while(c==1);
getch();
}
void Insert(int x)
{
if(rear==MAX-1)
printf("\nOverflow!!!");
else
{
if(rear==-1)
front=rear=0;
else
rear++;
a[rear]=x;
}
}
void Delete()
{
if(front==-1)
printf("\nUnderflow!!!");
else
{
printf("\nElement getting deleted=%d",a[front]);
if(front==rear)
front=rear=-1;
else
front++;
}
}
void DISPLAY()
{
int i;
if(front!=-1)
{
printf("\nThe queue is\n");
for(i=front;i<=rear;i++)
printf("%d\t",a[i]);
}
}
====================================================================
//Program 10
//WAP to implement a circular queue
#include<stdio.h>

#include<conio.h>
#define MAX 25
typedef struct CQ
{
int data[MAX];
int front,rear;
}CQ;
void initialize(CQ *);
int empty(CQ *);
int full(CQ *);
void insert(CQ *,int);
int deleteq(CQ *);
void print(CQ *);
void main()
{
int x,ch,n,c,i;
CQ q;
clrscr();
initialize(&q);
do
{
printf("\n1:Create\n2:Insert\n3:Delete\n4:Print");
printf("\nEnter your choice:");
scanf("%d",&ch);
switch(ch)
{
case 1:printf("Enter number of elements:");
scanf("%d",&n);
initialize(&q);
printf("Enter the elements\n");
for(i=0;i<n;i++)
{
scanf("%d",&x);
if(full(&q))
{
printf("\nOverflow!!!");
exit(0);
}
insert(&q,x);
}
break;
case 2:printf("\nEnter the element to be inserted:");
scanf("%d",&x);
if(full(&q))
{
printf("Overflow!!!");
exit(0);
}
insert(&q,x);
break;
case 3:if(empty(&q))
{
printf("\nUnderflow!!!");
exit(0);
}
x=deleteq(&q);
printf("\nElement getting deleted=%d",x);
break;
case 4:print(&q);

break;
default: printf("Wrong choice");
}
printf("\nDo you want to go back to menu(1:YES/2:NO)");
scanf("%d",&c);
}
while(c==1);
getch();
}
void initialize(CQ *p)
{
p->rear=-1;
p->front=-1;
}
int empty(CQ *p)
{
if(p->rear==-1)
return(1);
return(0);
}
int full(CQ *p)
{
if((p->rear+1)%MAX==p->front)
return(1);
return(0);
}
void insert(CQ *p,int x)
{
if(empty(p))
{
p->rear=p->front=0;
p->data[p->rear]=x;
}
else
{
p->rear=(p->rear+1)%MAX;
p->data[p->rear]=x;
}
}
int deleteq(CQ *p)
{
int x;
x=p->data[p->front];
if(p->rear==p->front)
initialize(p);
else
p->front=(p->front+1)%MAX;
return(x);
}
void print(CQ *p)
{
int i;
printf("\nThe queue is\n");
i=p->front;
while(i!=p->rear)
{
printf("%d\t",p->data[i]);
i=(i+1)%MAX;
}

printf("%d",p->data[p->rear]);
}
=================================================================
//Program 11
//WAP to implement BFS & DFS alogorithms
#include<stdio.h>
#include<conio.h>
#define MAX 20
typedef struct Q
{
int data[MAX];
int R,F;
}Q;
typedef struct node
{
struct node *next;
int vertex;
}node;
void enqueue(Q *,int);
int dequeue(Q *);
int empty(Q *);
int full(Q *);
void BFS(int);
void readgraph();
void insert(int,int);
void DFS(int);
int visited[MAX];
node *G[20];
int n;
void main()
{
int i,op,ch;
clrscr();
do
{
printf("1:Create\n2:BFS\n3:DFS\n");
printf("Enter your choice:");
scanf("%d",&op);
switch(op)
{
case 1:readgraph();
break;
case 2:printf("Enter starting node:");
scanf("%d",&i);
BFS(i);
break;
case 3:for(i=0;i<n;i++)
visited[i]=0;
printf("Enter starting node:");
scanf("%d",&i);
DFS(i);
break;
default :printf("\nWrong choice!!!");
}
printf("\nDo you want to go back(1:YES/2:NO)");

scanf("%d",&ch);
}while(ch==1);
getch();
}
void BFS(int v)
{
int w,i,visited[MAX];
Q q;
node *p;
q.R=q.F=-1;
for(i=0;i<n;i++)
visited[i]=0;
enqueue(&q,v);
printf("\nVisit:%d",v);
visited[v]=1;
while(!empty(&q))
{
v=dequeue(&q);
for(p=G[v];p!=NULL;p=p->next)
{
w=p->vertex;
if(visited[w]==0)
{
enqueue(&q,w);
visited[w]=1;
printf("\nVisit:%d",w);
}
}
}
}
void DFS(int i)
{
node *p;
printf("\n%d",i);
p=G[i];
visited[i]=1;
while(p!=NULL)
{
i=p->vertex;
if(!visited[i])
DFS(i);
p=p->next;
}
}
int empty(Q *P)
{
if(P->R==-1)
return(1);
return(0);
}
int full(Q *P)
{
if(P->R==MAX-1)
return(1);
return(0);
}
void enqueue(Q *P,int x)
{
if(P->R==-1)

{
P->R=P->F=0;
P->data[P->R]=x;
}
else
{
P->R=P->R+1;
P->data[P->R]=x;
}
}
int dequeue(Q *P)
{
int x;
x=P->data[P->F];
if(P->R==P->F)
{
P->R=P->F=-1;
return(x);
}
else
P->F=P->F+1;
return(x);
}
void readgraph()
{
int i,vi,vj,edge;
printf("Enter number of vertices:");
scanf("%d",&n);
for(i=0;i<n;i++)
G[i]=NULL;
printf("Enter number of edges:");
scanf("%d",&edge);
for(i=0;i<edge;i++)
{
printf("\nEnter an edge(u,v):");
scanf("%d%d",&vi,&vj);
insert(vi,vj);
}
}
void insert(int vi,int vj)
{
node *p,*q;
q=(node*)malloc(sizeof(node));
q->vertex=vj;
q->next=NULL;
if(G[vi]==NULL)
G[vi]=q;
else
{
p=G[vi];
while(p->next!=NULL)
p=p->next;
p->next=q;
}
}
================================================================
//Program 12
//WAP to sort an array using insertion sort

#include<stdio.h>
#include<conio.h>
void insertion_sort(int [],int);
void main()
{
int a[25],n,i;
clrscr();
printf("Enter no of elements:");
scanf("%d",&n);
printf("Enter array\n");
for(i=0;i<n;i++)
scanf("%d",&a[i]);
insertion_sort(a,n);
printf("\nSorted array is\n");
for(i=0;i<n;i++)
printf("%d\t",a[i]);
getch();
}
void insertion_sort(int a[],int n)
{
int i,j,temp;
for(i=1;i<n;i++)
{
temp=a[i];
j=i-1;
while(a[j]>temp&&j>=0)
{
a[j+1]=a[j];
j--;
}
a[j+1]=temp;
}
}
===============================================================
//Program 13
//WAP to implement merge sort
#include<stdio.h>
#include<conio.h>
#define MAX 20
void merge(int a[],int l,int m,int u);
void merge_sort(int a[],int i,int j);
void main()
{
int a[MAX],n,i;
clrscr();
printf("Enter number of elements:");
scanf("%d",&n);
printf("Enter elements\n");
for(i=0;i<n;i++)
scanf("%d",&a[i]);
merge_sort(a,0,n-1);
printf("\nSorted array is\n");
for(i=0;i<n;i++)
printf("%d\t",a[i]);
getch();

}
void merge_sort(int a[],int i,int j)
{
int k;
if(i<j)
{
k=(i+j)/2;
merge_sort(a,i,k);
merge_sort(a,k+1,j);
merge(a,i,k,j);
}
}
void merge(int a[],int l,int m,int u)
{
int c[MAX];
int i,j,k;
i=l;
j=m+1;
k=0;
while(i<=m&&j<=u)
{
if(a[i]<a[j])
c[k++]=a[i++];
else
c[k++]=a[j++];
}
while(i<=m)
c[k++]=a[i++];
while(j<=u)
c[k++]=a[j++];
for(i=l,j=0;i<=u;i++,j++)
a[i]=c[j];
}
===============================================================
//Program 14
//WAP to implement quick sort
#include<stdio.h>
#include<conio.h>
int partition(int [],int,int);
void quick_sort(int [],int,int);
void main()
{
int a[20],n,i;
clrscr();
printf("Enter no of elements(<=20):");
scanf("%d",&n);
printf("Enter elememts\n");
for(i=0;i<n;i++)
scanf("%d",&a[i]);
quick_sort(a,0,n-1);
printf("\nSorted array is\n");
for(i=0;i<n;i++)
printf("%d\t",a[i]);
getch();
}

void quick_sort(int a[],int l,int u)

{
int j;
if(l<u)
{
j=partition(a,l,u);
quick_sort(a,l,j-1);
quick_sort(a,j+1,u);
}
}
int partition(int a[],int l,int u)
{
int v,i,j,temp;
v=a[l];
i=l;
j=u+1;
do
{
do
i++;
while(a[i]<v&&i<=u);
do
j--;
while(v<a[j]);
if(i<j)
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
while(i<j);
a[l]=a[j];
a[j]=v;
return(j);
}
=====================================================================
//Program 15
//WAP to implement heap sort
#include<stdio.h>
#include<conio.h>
void create(int []);
void down_adjust(int [],int);
void main()
{
int heap[20],n,i,last,temp;
clrscr();
printf("Enter no. of elements:");
scanf("%d",&n);
printf("Enter the elements\n");
for(i=1;i<=n;i++)
scanf("%d",&heap[i]);
heap[0]=n;
create(heap);
while(heap[0]>1)
{

last=heap[0];
temp=heap[1];
heap[1]=heap[last];
heap[last]=temp;
heap[0]--;
down_adjust(heap,1);
}
printf("\nSorted array is\n");
for(i=1;i<=n;i++)
printf("%d\t",heap[i]);
getch();
}
void create(int heap[])
{
int i,n;
n=heap[0];
for(i=n/2;i>=1;i--)
down_adjust(heap,i);
}
void down_adjust(int heap[],int i)
{
int j,n,temp,flag=1;
n=heap[0];
while(2*i<=n&&flag==1)
{
j=2*i;
if(j+1<=n&&heap[j+1]>heap[j])
j=j+1;
if(heap[i]>heap[j])
flag=0;
else
{
temp=heap[i];
heap[i]=heap[j];
heap[j]=temp;
i=j;
}
}
}
================================================================================
===