1)Write a C program to implement array operations.

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

#include <stdio.h>
void insertbegin(int [],int *,int,int);
void insertend(int [],int *,int,int);
void insertany(int [],int *,int,int,int);
void deletebegin(int [],int *);
void deleteend(int [],int *);
void deleteany(int [],int *,int);
void display(int [],int);

void main()
{
int a[50],n;
int capacity=10;
int key,key1,key2;
int pos;
int ch;
printf("How many array elements do you want?:");
scanf("%d",&n);
printf("Enter array elements\n");
for(int i=0;i<n;i++)
{
printf("Enter element %d:",i+1);
scanf("%d",&a[i]);
}
printf("\nMENU\n");
printf("1:Insert at the beginning of the array.\n");
printf("2:Insert at the end of the array.\n");
printf("3:Insert at given position in the array.\n");
printf("4:Delete at the beginning of the array.\n");
printf("5:Delete at the end of the array.\n");
printf("6:Delete at given position in the array.\n");
printf("Enter your choice: ");
scanf("%d",&ch);

if(ch>0 && ch<7)

{
switch(ch)
{
case 1:
printf("enter the element you want to add at the beginning: ");
scanf("%d",&key);
printf("The array before inserting the element\n");
display(a,n);
printf("\n");
insertbegin(a,&n,capacity,key);
 printf("The array after inserting an element at the beginning\n");
display(a,n);
break;

case 2:
printf("enter the element you want to add at the end: ");
scanf("%d",&key1);
printf("The array before inserting the element\n");
display(a,n);
printf("\n");
insertend(a,&n,capacity,key1);
printf("The array after inserting element at the end\n");
display(a,n);
break;

case 3:
printf("enter the element you want to add at a position in the array: ");
scanf("%d",&key2);
printf("enter the position where you want to insert the element: ");
scanf("%d",&pos);
insertany(a,&n,capacity,key2,pos);
printf("The array after inserting element at any position\n");
display(a,n);
break;

case 4:
printf("The array before deleting the element at beginning\n");
display(a,n);
printf("\n");
deletebegin(a,&n);
printf("The array after deleting the element at beginning\n");
display(a,n);
break;

case 5:
printf("The array before deleting the element at end\n");
display(a,n);
printf("\n");
deleteend(a,&n);
printf("The array after deleting the element at end\n");
display(a,n);
break;

case 6:
printf("enter the position you want to delete: ");
scanf("%d",&pos);
printf("The array before deleting the element at position %d\n", pos);
display(a,n);
 printf("\n");
deleteany(a,&n,pos);
printf("The array after deleting the element at position %d\n", pos);
display(a,n);
break;

default:
break;
}
}
else
{
printf("Invalid choice.");
}
}

void display(int a[],int n)

{
for(int i=0;i<n;i++)
{
printf("%d ",a[i]);
}
printf("\n");
}

void insertbegin(int a[],int *n,int capacity,int key)

{
if(*n>=capacity)
{
printf("The operation can't be done.\n");
}
else
{
for(int i=*n;i>0;i--)
{
a[i]=a[i-1];
}
a[0]=key;
(*n)++;
}
}

void insertend(int a[],int *n,int capacity,int key1)

{
if(*n>=capacity)
{
printf("The operation can't be done.\n");
}
 else
{
a[*n]=key1;
(*n)++;
}
}

void insertany(int a[],int *n,int capacity,int key2,int pos)

{
if(*n>=capacity || pos<0 || pos>*n)
{
printf("The operation can't be done.\n");
}
else
{
for(int i=*n;i>pos;i--)
{
a[i]=a[i-1];
}
a[pos]=key2;
(*n)++;
}
}

void deletebegin(int a[],int *n)

{
if(*n<=0)
{
printf("The array is empty.\n");
}
else
{
for(int i=0;i<*n-1;i++)
{
a[i]=a[i+1];
}
(*n)--;
}
}

void deleteend(int a[],int *n)

{
if(*n<=0)
{
printf("The array is empty.\n");
}
else
{
 (*n)--;
}
}

void deleteany(int a[],int *n,int pos)

{
if(*n<=0 || pos<0 || pos>=*n)
{
printf("The operation can't be done.\n");
}
else
{
for(int i=pos;i<*n-1;i++)
{
a[i]=a[i+1];
}
(*n)--;
}
}
2)Write a C program to implement linear search.
=====================================

#include <stdio.h>
void main()
{
int i,n,flag=0,index,key;
int a[20];
printf("How many elements do you want to enter?");
scanf("%d",&n);
printf("Enter array elements\n");
for(i=0;i<n;i++)
{
printf("Enter element %d:",i+1);
scanf("%d",&a[i]);
}
printf("Enter the key element to be searched in the array:");
scanf("%d",&key);
for(i=0;i<n;i++)
{
if(a[i]==key)
{
flag++;
index=i;
}
}
if(flag==0)
{
printf("Key element %d not found in the array.",key);
 }
else
{
printf("Key element %d found in the array at the position %d.",key,index);
}
}
3)Write a C program to implement binary search with and without recursion.
============================================================

#include <stdio.h>
int binaryrecur(int[],int,int,int);
int binarysearch(int[],int,int,int);
void main()
{
int arr[] = {10, 20, 30, 40, 50};
int n = sizeof(arr) / sizeof(arr[0]);
int key;
printf("Enter the key:");
scanf("%d",&key);
int low = 0, high = n - 1;
int result = binarysearch(arr,key,low,high);
printf("without recursion\n");
if (result == -1)
{
printf("Element %d not found.\n",key);
}
else
{
printf("Element %d found at index %d.\n", key,result);
}
printf("with recursion\n");
int res=binaryrecur(arr,key,low,high);
if (result == -1)
{
printf("Element %d not found.\n",key);
}
else
{
printf("Element %dfound at index %d.\n", key,result);
}
}
int binarysearch(int arr[],int key,int low,int high)
{
int mid;
while (low <= high)
{
mid = (low + high) / 2;
 if (arr[mid] == key)
{
return mid;
}
else if (key < arr[mid])
{
high = mid - 1;
}
else
{
low = mid + 1;
}
}
return -1;
}
int binaryrecur(int arr[],int key,int low,int high)
{
if(low<=high)
{
int mid=(low+high)/2;
if(key==arr[mid])
{
return mid;
}
else if(key<arr[mid])
{
return binaryrecur(arr,key,low,high-1);
}
else
{
return binaryrecur(arr,key,mid+1,high);
}
}
return -1;
}
4)Write a C program to implement bubblesort.
===================================
#include <stdio.h>
void bubbleSort(int[],int);
void main()
{
int arr[] = {64, 25, 12, 22, 11};
int n = sizeof(arr) / sizeof(arr[0]);
printf("Original array: ");

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

{
printf("%d ", arr[i]);
 }
printf("\\n");

bubbleSort(arr, n);

printf("Sorted array: ");

for (int i = 0; i < n; i++)
{
printf("%d ", arr[i]);
}
printf("\\n");
}
void bubbleSort(int arr[], int n)
{
int i, j, temp;
for (i = 0; i < n - 1; i++)
{
for (j = 0; j < n - 1 - i; j++)
{
if (arr[j] > arr[j + 1])
{
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
5)Write a C program to implement selection sort.
======================================

#include <stdio.h>
void selectionsort(int[],int);
void main()
{
int arr[] = {64, 25, 12, 22, 11};
int n = sizeof(arr) / sizeof(arr[0]);
printf("Original array: ");

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

{
printf("%d ", arr[i]);
}
printf("\n");

selectionsort(arr, n);

printf("Sorted array: ");

 for (int i = 0; i < n; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
void selectionsort(int arr[], int n)
{
int i, j, min, temp;

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

{
min = i;
for (j = i + 1; j < n; j++)
{
if (arr[j] < arr[min])
{
min = j;
}
}
if (min != i)
{
temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}
}
6)Write a C program to implement insertion sort.
=======================================
#include <stdio.h>
void insertionsort(int[],int);
void main()
{
int i,n;
int a[20];
printf("How many elements do you want to enter?");
scanf("%d",&n);
printf("Enter array elements\n");
for(i=0;i<n;i++)
{
printf("Enter element %d:",i+1);
scanf("%d",&a[i]);
}
printf("Array elements before sorting:");
for(i=0;i<n;i++)
{
printf("%d ",a[i]);
 }
printf("\n");
insertionsort(a,n);
printf("Array elements after sorting:");
for(i=0;i<n;i++)
{
printf("%d ",a[i]);
}
}
void insertionsort(int a[],int n)
{
int j,i,temp;
for(i=1;i<n;i++)
{
temp=a[i];
j=i-1;
while(j>=0 && a[j]>temp)
{
a[j+1]=a[j];
j--;
}
a[j+1]=temp;
}
}
7)Write a C program to implement Single Linked list(all operations)
=====================================================

#include<stdio.h>
#include<stdlib.h>
void list(int);
void insert_begin(int);
void insert_end(int);
void insert_at_position(int,int);
void delete_begin();
void delete_end();
void delete_at_position(int );
void display();
int count();
void search(int);
struct node
{
int data;
struct node *link;
};
struct node *head=NULL;
struct node *tail=NULL;
void main()
{
int ele, ch, pos,n;

while (1) {
printf("\n1.Create List\n2.Insert at Beginning\n3.Insert at End\n4.Insert at Position");
printf("\n5.Delete from Beginning\n6.Delete from End\n7.Delete at Position");
printf("\n8.Search\n9.Display\n10.Count\n11.Exit");
printf("\nEnter your choice: ");
scanf("%d", &ch);

switch (ch) {
case 1:
printf("Enter no of elements you want to add: ");
scanf("%d", &n);
list(n);
break;
case 2:
printf("Enter element: ");
scanf("%d", &ele);
insert_begin(ele);
break;
case 3:
printf("Enter element: ");
scanf("%d", &ele);
insert_end(ele);
break;
case 4:
printf("Enter element: ");
scanf("%d", &ele);
printf("Enter position:");
scanf("%d",&pos);
insert_at_position(ele,pos);
break;
case 5:
delete_begin();
break;
case 6:
delete_end();
break;
case 7:
printf("Enter position: ");
scanf("%d", &pos);
delete_at_position(pos);
break;
case 8:
printf("Enter element to search: ");
scanf("%d", &ele);
search(ele);
break;
 case 9:
display();
break;
case 10:
printf("Total nodes = %d\n", count());
break;
case 11:
exit(0);
default:
printf("INVALID CHOICE\n");
}
}
}
void list(int n)
{
int ele;
struct node *newnode=NULL;
for(int i=0;i<n;i++)
{
newnode=(struct node*)malloc(sizeof(struct node));
if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
printf("Enter the element:");
scanf("%d",&ele);
newnode->data=ele;
newnode->link=NULL;
if(head==NULL)
{
head=newnode;
tail=newnode;
}
else
{
tail->link=newnode;
tail=newnode;
}
}
}
void display()
{
struct node *temp=NULL;
temp=head;
while(temp!=NULL)
{
printf("%d ",temp->data);
temp=temp->link;
 }
}
void insert_begin(int ele)
{
struct node *newnode=NULL;
newnode=(struct node*)malloc(sizeof(struct node));
if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
newnode->data=ele;
newnode->link=NULL;
if(head==NULL)
{
head=newnode;
tail=newnode;
}
else
{
newnode->link=head;
head=newnode;
}
}

void insert_end(int ele)

{
struct node *newnode=NULL;
newnode=(struct node*)malloc(sizeof(struct node));
if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
newnode->data=ele;
newnode->link=NULL;
if(head==NULL)
{
head=newnode;
tail=newnode;
}
else
{
tail->link=newnode;
tail=newnode;
}
}
void insert_at_position(int ele,int pos)
{
int c=count();
 if(pos <1||pos>(c+1))
{
printf("Invalid position.\n");
}
else if(pos==1)
{
insert_begin(ele);
}
else if(pos==c+1)
{
insert_end(ele);
}
else
{
struct node *newnode=NULL;
newnode=(struct node*)malloc(sizeof(struct node));
if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
newnode->data=ele;
newnode->link=NULL;
struct node *curnode=NULL;
curnode=head;
for(int i=2;i<pos;i++)
{
curnode=curnode->link;
}
newnode->link=curnode->link;
curnode->link=newnode;
}
}
void delete_begin()
{
if(head==NULL)
{
printf("Linked list is empty.\n");
}
else if(head==tail)
{
struct node *todel=NULL;
todel=head;
head=NULL;
tail=NULL;
printf("%d deleted.",todel->data);
free(todel);
}
else
 {
struct node *todel=NULL;
todel=head;
head=head->link;
todel->link=NULL;
printf("%d deleted.",todel->data);
free(todel);
}
}
void delete_end()
{
if(head==NULL)
{
printf("Linked list is empty.\n");
}
else if(head==tail)
{
struct node *todel=NULL;
todel=head;
head=NULL;
tail=NULL;
printf("%d deleted.",todel->data);
free(todel);
}
else
{
struct node *todel=NULL;
struct node *prev=NULL;
todel=head;
while(todel->link!=NULL)
{
prev=todel;
todel=todel->link;
}
prev->link=NULL;
tail=prev;
printf("%d deleted.",todel->data);
free(todel);
}
}
void delete_at_position(int pos)
{
int c=count();
if(pos <1||pos>(c))
{
printf("Invalid position.\n");
}
else if(pos==1)
 {
delete_begin();
}
else if(pos==c)
{
delete_end();
}
else
{
struct node *todel=NULL;
struct node *prev=NULL;
todel=head;
for(int i=2;i<=pos;i++)
{
prev=todel;
todel=todel->link;
}
prev->link=todel->link;
todel->link=NULL;
printf("%d deleted.\n",todel->data);
free(todel);
}
}
void search(int key)
{
int flag=0,index=0;
struct node *temp=NULL;
temp=head;
while(temp!=NULL)
{
index++;
if(key==temp->data)
{
flag++;
break;
}
temp=temp->link;
}
if(flag==0)
{
printf("Key %d not found.\n",key);
}
else
{
printf("Key %d found at index position %d.\n",key,index);
}
}
int count()
{
int count=0;
struct node *temp=NULL;
temp=head;
while(temp!=NULL)
{
count++;
temp=temp->link;
}
return count;
}
8)Write a C program to implement Double Linked list(all operations).
======================================================
#include<stdio.h>
#include<stdlib.h>
void list(int);
void insert_begin(int);
void insert_end(int);
void insert_at_position(int,int);
void delete_begin();
void delete_end();
void delete_at_position(int );
void display();
int count();
void search(int);
struct node
{
int data;
struct node *prev;
struct node *next;

};
struct node *head=NULL;
struct node *tail=NULL;
void main()
{
int ele, ch, pos,n;

while (1) {
printf("\n1.Create List\n2.Insert at Beginning\n3.Insert at End\n4.Insert at Position");
printf("\n5.Delete from Beginning\n6.Delete from End\n7.Delete at Position");
printf("\n8.Search\n9.Display\n10.Count\n11.Exit");
printf("\nEnter your choice: ");
scanf("%d", &ch);

switch (ch) {
case 1:
printf("Enter no of elements you want to add: ");
 scanf("%d", &n);
list(n);
break;
case 2:
printf("Enter element: ");
scanf("%d", &ele);
insert_begin(ele);
break;
case 3:
printf("Enter element: ");
scanf("%d", &ele);
insert_end(ele);
break;
case 4:
printf("Enter element: ");
scanf("%d", &ele);
printf("Enter position:");
scanf("%d",&pos);
insert_at_position(ele,pos);
break;
case 5:
delete_begin();
break;
case 6:
delete_end();
break;
case 7:
printf("Enter position: ");
scanf("%d", &pos);
delete_at_position(pos);
break;
case 8:
printf("Enter element to search: ");
scanf("%d", &ele);
search(ele);
break;
case 9:
display();
break;
case 10:
printf("Total nodes = %d\n", count());
break;
case 11:
exit(0);
default:
printf("INVALID CHOICE\n");
}
}
}
void list(int n)
{
int ele;
struct node *newnode=NULL;
for(int i=0;i<n;i++)
{
newnode=(struct node*)malloc(sizeof(struct node));
if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
printf("Enter element %d:",i+1);
scanf("%d",&ele);
newnode->data=ele;
newnode->prev=NULL;
newnode->next=NULL;
if(head==NULL)
{
head=newnode;
tail=newnode;
}
else
{
tail->next=newnode;
newnode->prev=tail;
tail=newnode;
}
}
}
void display()
{
struct node *temp=NULL;
temp=head;
while(temp!=NULL)
{
printf("%d ",temp->data);
temp=temp->next;
}
}
void insert_begin(int ele)
{
struct node *newnode=NULL;
newnode=(struct node*)malloc(sizeof(struct node));
if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
 newnode->data=ele;
newnode->prev=NULL;
newnode->next=NULL;
if(head==NULL)
{
head=newnode;
tail=newnode;
printf("%d inserted.\n",ele);
}
else
{
head->prev=newnode;
newnode->next=head;
head=newnode;
printf("%d inserted.\n",ele);
}
}
void insert_end(int ele)
{
struct node *newnode=NULL;
newnode=(struct node*)malloc(sizeof(struct node));
if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
newnode->data=ele;
newnode->prev=NULL;
newnode->next=NULL;
if(head==NULL)
{
head=newnode;
tail=newnode;
printf("%d inserted.\n",ele);
}
else
{
tail->next=newnode;
newnode->prev=tail;
tail=newnode;
printf("%d inserted.\n",ele);
}
}
void insert_at_position(int ele,int pos)
{
int c=count();
if(pos <1||pos>(c+1))
{
printf("Invalid position.\n");
 }
else if(pos==1)
{
insert_begin(ele);
}
else if(pos==c+1)
{
insert_end(ele);
}
else
{
struct node *newnode=NULL;
newnode=(struct node*)malloc(sizeof(struct node));
if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
newnode->data=ele;
newnode->prev=NULL;
newnode->next=NULL;
struct node *temp=NULL;
temp=head;
for(int i=2;i<pos;i++)
{
temp=temp->next;
}
newnode->next=temp->next;
temp->next->prev=newnode;
temp->next=newnode;
newnode->prev=temp;
printf("%d inserted.\n",ele);
}
}
void delete_begin()
{
struct node *todel=NULL;
if(head==NULL)
{
printf("list is empty.\n");
}
else if(head==tail)
{
todel=head;
head=NULL;
tail=NULL;
printf("%d deleted.\n",todel->data);
free(todel);
}
 else
{
todel=head;
head=head->next;
head->prev=NULL;
todel->next=NULL;
printf("%d deleted.\n",todel->data);
free(todel);
}
}
void delete_end()
{
struct node *todel=NULL;
if(head==NULL)
{
printf("list is empty.\n");
}
else if(head==tail)
{
todel=tail;
head=NULL;
tail=NULL;
printf("%d deleted.\n",todel->data);
free(todel);
}
else
{
todel=tail;
tail=tail->prev;
tail->next=NULL;
todel->prev=NULL;
printf("%d deleted.\n",todel->data);
free(todel);

}
}
void delete_at_position(int pos)
{
int c=count();
if(pos <1||pos>(c))
{
printf("Invalid position.\n");
}
else if(pos==1)
{
delete_begin();
}
else if(pos==c)
 {
delete_end();
}
else
{
struct node *todel=NULL;
todel=head;
for(int i=2;i<=pos;i++)
{
todel=todel->next;
}
todel->prev->next=todel->next;
todel->next->prev=todel->prev;
todel->next=NULL;
todel->prev=NULL;
printf("%d deleted.\n",todel->data);
free(todel);
}
}
int count()
{
int count=0;
struct node *temp=NULL;
temp=head;
while(temp!=NULL)
{
count++;
temp=temp->next;
}
return count;
}
void search(int key)
{
int flag=0,index=0;
struct node *temp=NULL;
temp=head;
while(temp!=NULL)
{
index++;
if(temp->data==key)
{
flag++;
break;
}
temp=temp->next;
}
if(flag==0)
{
 printf("Key %d not found.",key);
}
else
{
printf("Key %d found at index %d",key,index);
}
}
9)Write a C program to implement Circular Single linked list(all operations)
==========================================================
#include<stdio.h>
#include<stdlib.h>
void list(int);
void insert_begin(int);
void insert_end(int);
void insert_at_position(int,int);
void delete_begin();
void delete_end();
void delete_at_position(int );
void display();
int count();
void search(int);
struct node
{
int data;
struct node *link;
};
struct node *head=NULL;
struct node *tail=NULL;
void main()
{
int ele, ch, pos,n;

while (1) {
printf("\n1.Create List\n2.Insert at Beginning\n3.Insert at End\n4.Insert at Position");
printf("\n5.Delete from Beginning\n6.Delete from End\n7.Delete at Position");
printf("\n8.Search\n9.Display\n10.Count\n11.Exit");
printf("\nEnter your choice: ");
scanf("%d", &ch);

switch (ch) {
case 1:
printf("Enter no of elements you want to add: ");
scanf("%d", &n);
list(n);
break;
case 2:
printf("Enter element: ");
scanf("%d", &ele);
 insert_begin(ele);
break;
case 3:
printf("Enter element: ");
scanf("%d", &ele);
insert_end(ele);
break;
case 4:
printf("Enter element: ");
scanf("%d", &ele);
printf("Enter position:");
scanf("%d",&pos);
insert_at_position(ele,pos);
break;
case 5:
delete_begin();
break;
case 6:
delete_end();
break;
case 7:
printf("Enter position: ");
scanf("%d", &pos);
delete_at_position(pos);
break;
case 8:
printf("Enter element to search: ");
scanf("%d", &ele);
search(ele);
break;
case 9:
display();
break;
case 10:
printf("Total nodes = %d\n", count());
break;
case 11:
exit(0);
default:
printf("INVALID CHOICE\n");
}
}
}
void list(int n)
{
int ele;
struct node *newnode=NULL;
for(int i=0;i<n;i++)
 {
newnode=(struct node*)malloc(sizeof(struct node));
if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
printf("Enter the element:");
scanf("%d",&ele);
newnode->data=ele;
newnode->link=NULL;
if(head==NULL)
{
head=newnode;
tail=newnode;
tail->link=head;
}
else
{
tail->link=newnode;
tail=newnode;
tail->link=head;
}
}
}
void display()
{
struct node *temp=NULL;
temp=head;
do
{
printf("%d ",temp->data);
temp=temp->link;

}while(temp!=head);
}
void insert_begin(int ele)
{
struct node *newnode=NULL;
newnode=(struct node*)malloc(sizeof(struct node));
if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
newnode->data=ele;
newnode->link=NULL;
if(head==NULL)
{
head=newnode;
 tail=newnode;
tail->link=newnode;
}
else
{
newnode->link=head;
head=newnode;
tail->link=newnode;
}
}

void insert_end(int ele)

{
struct node *newnode=NULL;
newnode=(struct node*)malloc(sizeof(struct node));
if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
newnode->data=ele;
newnode->link=NULL;
if(head==NULL)
{
head=newnode;
tail=newnode;
tail->link=head;
}
else
{
tail->link=newnode;
tail=newnode;
tail->link=head;
}
}
void insert_at_position(int ele,int pos)
{
int c=count();
if(pos <1||pos>(c+1))
{
printf("Invalid position.\n");
}
else if(pos==1)
{
insert_begin(ele);
}
else if(pos==c+1)
{
insert_end(ele);
 }
else
{
struct node *newnode=NULL;
newnode=(struct node*)malloc(sizeof(struct node));
if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
newnode->data=ele;
newnode->link=NULL;
struct node *curnode=NULL;
curnode=head;
for(int i=2;i<pos;i++)
{
curnode=curnode->link;
}
newnode->link=curnode->link;
curnode->link=newnode;
}
}
void delete_begin()
{
if(head==NULL)
{
printf("Linked list is empty.\n");
}
else if(head==tail)
{
struct node *todel=NULL;
todel=head;
head=NULL;
tail=NULL;
printf("%d deleted.",todel->data);
free(todel);
}
else
{
struct node *todel=NULL;
todel=head;
head=head->link;
todel->link=NULL;
printf("%d deleted.",todel->data);
free(todel);
tail->link=head;
}
}
void delete_end()
{
if(head==NULL)
{
printf("Linked list is empty.\n");
}
else if(head==tail)
{
struct node *todel=NULL;
todel=head;
head=NULL;
tail=NULL;
printf("%d deleted.",todel->data);
free(todel);
}
else
{
struct node *todel=NULL;
struct node *prev=NULL;
todel=head;
do
{
prev=todel;
todel=todel->link;
}while(todel->link!=tail);

prev->link=NULL;
tail=prev;
tail->link=head;
printf("%d deleted.",todel->data);
free(todel);
}
}
void delete_at_position(int pos)
{
int c=count();
if(pos <1||pos>(c))
{
printf("Invalid position.\n");
}
else if(pos==1)
{
delete_begin();
}
else if(pos==c)
{
delete_end();
}
else
 {
struct node *todel=NULL;
struct node *prev=NULL;
todel=head;
for(int i=2;i<=pos;i++)
{
prev=todel;
todel=todel->link;
}
prev->link=todel->link;
todel->link=NULL;
printf("%d deleted.\n",todel->data);
free(todel);
}
}
void search(int key)
{
int flag=0,index=0;
struct node *temp=NULL;
temp=head;
do
{
index++;
if(key==temp->data)
{
flag++;
break;
}
temp=temp->link;
}while(temp!=head);
if(flag==0)
{
printf("Key %d not found.\n",key);
}
else
{
printf("Key %d found at index position %d.\n",key,index);
}
}
int count()
{
int count=0;
struct node *temp=NULL;
temp=head;
do
{
count++;
temp=temp->link;
 }while(temp!=head);
return count;
}
10)Write a C program to implement circular double linked list(all operations).
===========================================================
#include<stdio.h>
#include<stdlib.h>
void list(int);
void insert_begin(int);
void insert_end(int);
void insert_at_position(int,int);
void delete_begin();
void delete_end();
void delete_at_position(int );
void display();
int count();
void search(int);
struct node
{
int data;
struct node *prev;
struct node *next;

};
struct node *head=NULL;
struct node *tail=NULL;
void main()
{
int ele, ch, pos,n;

while (1) {
printf("\n1.Create List\n2.Insert at Beginning\n3.Insert at End\n4.Insert at Position");
printf("\n5.Delete from Beginning\n6.Delete from End\n7.Delete at Position");
printf("\n8.Search\n9.Display\n10.Count\n11.Exit");
printf("\nEnter your choice: ");
scanf("%d", &ch);

switch (ch) {
case 1:
printf("Enter no of elements you want to add: ");
scanf("%d", &n);
list(n);
break;
case 2:
printf("Enter element: ");
scanf("%d", &ele);
insert_begin(ele);
break;
 case 3:
printf("Enter element: ");
scanf("%d", &ele);
insert_end(ele);
break;
case 4:
printf("Enter element: ");
scanf("%d", &ele);
printf("Enter position:");
scanf("%d",&pos);
insert_at_position(ele,pos);
break;
case 5:
delete_begin();
break;
case 6:
delete_end();
break;
case 7:
printf("Enter position: ");
scanf("%d", &pos);
delete_at_position(pos);
break;
case 8:
printf("Enter element to search: ");
scanf("%d", &ele);
search(ele);
break;
case 9:
display();
break;
case 10:
printf("Total nodes = %d\n", count());
break;
case 11:
exit(0);
default:
printf("INVALID CHOICE\n");
}
}
}
void list(int n)
{
int ele;
struct node *newnode=NULL;
for(int i=0;i<n;i++)
{
newnode=(struct node*)malloc(sizeof(struct node));
 if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
printf("Enter element %d:",i+1);
scanf("%d",&ele);
newnode->data=ele;
newnode->prev=NULL;
newnode->next=NULL;
if(head==NULL)
{
head=newnode;
tail=newnode;
}
else
{
tail->next=newnode;
newnode->prev=tail;
tail=newnode;
tail->next=head;
head->prev=tail;
}
}
}
void display()
{
struct node *temp=NULL;
temp=head;
do
{
printf("%d ",temp->data);
temp=temp->next;
}while(temp!=head);
}
void insert_begin(int ele)
{
struct node *newnode=NULL;
newnode=(struct node*)malloc(sizeof(struct node));
if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
newnode->data=ele;
newnode->prev=NULL;
newnode->next=NULL;
if(head==NULL)
{
head=newnode;
 tail=newnode;
printf("%d inserted.\n",ele);
}
else
{
head->prev=newnode;
newnode->next=head;
head=newnode;
tail->next=head;
head->prev=tail;
printf("%d inserted.\n",ele);
}
}
void insert_end(int ele)
{
struct node *newnode=NULL;
newnode=(struct node*)malloc(sizeof(struct node));
if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
newnode->data=ele;
newnode->prev=NULL;
newnode->next=NULL;
if(head==NULL)
{
head=newnode;
tail=newnode;
printf("%d inserted.\n",ele);
}
else
{
tail->next=newnode;
newnode->prev=tail;
tail=newnode;
tail->next=head;
head->prev=tail;
printf("%d inserted.\n",ele);
}
}
void insert_at_position(int ele,int pos)
{
int c=count();
if(pos <1||pos>(c+1))
{
printf("Invalid position.\n");
}
else if(pos==1)
 {
insert_begin(ele);
}
else if(pos==c+1)
{
insert_end(ele);
}
else
{
struct node *newnode=NULL;
newnode=(struct node*)malloc(sizeof(struct node));
if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
newnode->data=ele;
newnode->prev=NULL;
newnode->next=NULL;
struct node *temp=NULL;
temp=head;
for(int i=2;i<pos;i++)
{
temp=temp->next;
}
newnode->next=temp->next;
temp->next->prev=newnode;
temp->next=newnode;
newnode->prev=temp;
printf("%d inserted.\n",ele);
}
}
void delete_begin()
{
struct node *todel=NULL;
if(head==NULL)
{
printf("list is empty.\n");
}
else if(head==tail)
{
todel=head;
head=NULL;
tail=NULL;
printf("%d deleted.\n",todel->data);
free(todel);
}
else
{
 todel=head;
head=head->next;
head->prev=tail;
todel->next=NULL;
printf("%d deleted.\n",todel->data);
free(todel);
}
}
void delete_end()
{
struct node *todel=NULL;
if(head==NULL)
{
printf("list is empty.\n");
}
else if(head==tail)
{
todel=tail;
head=NULL;
tail=NULL;
printf("%d deleted.\n",todel->data);
free(todel);
}
else
{
todel=tail;
tail=tail->prev;
tail->next=NULL;
todel->prev=NULL;
printf("%d deleted.\n",todel->data);
free(todel);
tail->next=head;
head->prev=tail;

}
}
void delete_at_position(int pos)
{
int c=count();
if(pos <1||pos>(c))
{
printf("Invalid position.\n");
}
else if(pos==1)
{
delete_begin();
}
else if(pos==c)
 {
delete_end();
}
else
{
struct node *todel=NULL;
todel=head;
for(int i=2;i<=pos;i++)
{
todel=todel->next;
}
todel->prev->next=todel->next;
todel->next->prev=todel->prev;
todel->next=NULL;
todel->prev=NULL;
printf("%d deleted.\n",todel->data);
free(todel);
}
}
int count()
{
int count=0;
struct node *temp=NULL;
temp=head;
do
{
count++;
temp=temp->next;
}while(temp!=head);
return count;
}
void search(int key)
{
int flag=0,index=0;
struct node *temp=NULL;
temp=head;
do
{
index++;
if(temp->data==key)
{
flag++;
break;
}
temp=temp->next;
}while(temp!=head);

if(flag==0)
 {
printf("Key %d not found.",key);
}
else
{
printf("Key %d found at index %d",key,index);
}
}
11)Write a C program to implement polynomial representation.
================================================
#include <stdio.h>
#include<stdlib.h>
void polyeq(int n);
void display();
struct node
{
float coeff;
int expo;
struct node *link;
};
struct node *head=NULL;

void main()
{
int n;
printf("Enter the no of terms for the polynomial equation:");
scanf("%d",&n);
polyeq(n);
printf("The polynomial equation is:");
display();
}
void polyeq(int n)
{
struct node *newnode=NULL;
for(int i=0;i<n;i++)
{
newnode=(struct node*)malloc(sizeof(struct node));
if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
float co;
int ex;
printf("Enter coefficient:");
scanf("%f",&co);
printf("Enter exponent:");
scanf("%d",&ex);
newnode->coeff=co;
 newnode->expo=ex;
newnode->link=NULL;
if(head==NULL||head->expo<ex)
{
newnode->link=head;
head=newnode;
}
else
{
struct node *temp=head;
while(temp->link!=NULL && temp->link->expo>=ex)
{
temp=temp->link;
}
newnode->link=temp->link;
temp->link=newnode;
}
}
}
void display()
{
struct node *temp=NULL;
temp=head;
while(temp!=NULL)
{
printf("%.1fx^%d",temp->coeff,temp->expo);
temp=temp->link;
if(temp!=NULL)
{
printf("+");
}
}
}
12)Write a C program to implement polynomial addition representation.
=======================================================
#include<stdio.h>
#include<stdlib.h>
struct node
{
float coeff;
int expo;
struct node* link;
};
void createList1(int);
void createList2(int);
void displayList(struct node *);
void insert(float, int);
void add(struct node *, struct node *);
struct node *head1=NULL;
struct node *head2=NULL;
struct node *head3=NULL;
void main()
{
int n1,n2;
printf("Enter the no.of terms for P1:\n");
scanf("%d",&n1);

createList1(n1);
displayList(head1);

printf("Enter the no.of terms for P2:\n");

scanf("%d",&n2);

createList2(n2);
displayList(head2);

add(head1,head2);
displayList(head3);
}
void insert(float co,int expo)
{
struct node* newnode=malloc(sizeof(struct node));
newnode->coeff=co;
newnode->expo=expo;
newnode->link=NULL;

if(head3==NULL || head3->expo<expo)
{
newnode->link=head3;
head3=newnode;
}
else
{
struct node* temp=head3;
while(temp->link!=NULL && temp->link->expo>=expo)
{
temp=temp->link;
}
newnode->link=temp->link;
temp->link=newnode;
}
}
void add(struct node* head1,struct node* head2)
{
struct node* temp1=head1;
 struct node* temp2=head2;

while(temp1!=NULL && temp2!=NULL)

{
if(temp1->expo==temp2->expo)
{
insert(temp1->coeff+temp2->coeff,temp1->expo);
temp1=temp1->link;
temp2=temp2->link;
}
else if(temp1->expo>temp2->expo)
{
insert(temp1->coeff,temp1->expo);
temp1=temp1->link;
}
else if(temp2->expo>temp1->expo)
{
insert(temp2->coeff,temp2->expo);
temp2=temp2->link;
}
}
while(temp1!=NULL)
{
insert(temp1->coeff,temp1->expo);
temp1=temp1->link;
}
while(temp2!=NULL)
{
insert(temp2->coeff,temp2->expo);
temp2=temp2->link;
}
}
void createList1(int n)
{
int expo;
float co;

for(int i=0;i<n;i++)
{
printf("\nEnter the coefficient of term %d: ",i+1);
scanf("%f",&co);
printf("\nEnter the exponent of term %d: ",i+1);
scanf("%d",&expo);

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

newnode->coeff=co;
newnode->expo=expo;
 newnode->link=NULL;

if(head1==NULL || head1->expo<expo)
{
newnode->link=head1;
head1=newnode;
}
else
{
struct node* temp=head1;
while(temp->link!=NULL && temp->link->expo>=expo)
{
temp=temp->link;
}
newnode->link=temp->link;
temp->link=newnode;
}

}
}

void createList2(int n)
{
int expo;
float co;

for(int i=0;i<n;i++)
{
printf("\nEnter the coefficient of term %d: ",i+1);
scanf("%f",&co);
printf("\nEnter the exponent of term %d: ",i+1);
scanf("%d",&expo);

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

newnode->coeff=co;
newnode->expo=expo;
newnode->link=NULL;

if(head2==NULL || head2->expo<expo)
{
newnode->link=head2;
head2=newnode;
}
else
{
struct node* temp=head2;
while(temp->link!=NULL && temp->link->expo>=expo)
{
 temp=temp->link;
}
newnode->link=temp->link;
temp->link=newnode;
}

}
}
void displayList(struct node *head)
{
struct node* temp=head;
while(temp!=NULL)
{
printf("(%.1fx^%d)",temp->coeff,temp->expo);
temp=temp->link;
if(temp!=NULL)
{
printf("+");
}
else
printf("\n");
}
}
13)Write a C program to implement all operations of stack using arrays.
======================================================
#include <stdio.h>
#include<stdlib.h>
#define SIZE 5
int top=-1;
int stack[SIZE];
void push(int);
void pop();
void peek();
void isunderflow();
void isoverflow();
void display();
void main()
{
int ele,ch;
while(1)
{
printf("\n1.Push\n2.Pop\n3.Peek\n4.Isunderflow\n5.Isoverflow\n6.Display\n7.Exit\n");
printf("Please enter your choice:");
scanf("%d",&ch);
switch(ch)
{
case 1:
printf("Enter element:");
 scanf("%d",&ele);
push(ele);
break;
case 2:
pop();
break;
case 3:
peek();
break;
case 4:
isunderflow();
break;
case 5:
isoverflow();
break;
case 6:
display();
break;
case 7:
exit(0);
default:
printf("INVALID CHOICE\n");
}
}
}
void push(int ele)
{
if(top==SIZE-1)
{
printf("Stack is full.\n");
}
else
{
top++;
stack[top]=ele;
printf("%d is inserted into the stack.\n",ele);
}
}
void pop()
{
if(top==-1)
{
printf("Stack is empty.\n");
}
else
{
printf("%d is removed out of the stack.\n",stack[top]);
top--;
 }
}
void peek()
{
if(top==-1)
{
printf("Stack is empty\n");
}
else
{
printf("The peek value of the stack is:%d\n",stack[top]);
}
}
void isunderflow()
{
if(top==-1)
{
printf("Stack underflow.\n");
}
else
{
printf("Stack is not underflow.\n");
}
}
void isoverflow()
{
if(top==SIZE-1)
{
printf("Stack overflow.\n");
}
else
{
printf("Stack is not overflow.\n");
}
}
void display()
{
if(top==-1)
{
printf("Stack is empty.\n");
}
else
{
for(int i=top;i>=0;i--)
{
printf("%d\n",stack[i]);
}
}
}
14)Write a C program to implement all operations of stack using linked lists.
=========================================================
#include <stdio.h>
#include<stdlib.h>
#define SIZE 10
struct stack
{
int data;
struct stack *link;
};
struct stack *top=NULL;
int count=0;

void push(int);
void pop();
void peek();
void isunderflow();
void isoverflow();
void display();
void main()
{
int ele,ch;
while(1)
{
printf("\n1.Push\n2.Pop\n3.Peek\n4.Isunderflow\n5.Isoverflow\n6.Display\n7.Exit\n");
printf("Please enter your choice:");
scanf("%d",&ch);
switch(ch)
{
case 1:
printf("Enter element:");
scanf("%d",&ele);
push(ele);
break;
case 2:
pop();
break;
case 3:
peek();
break;
case 4:
isunderflow();
break;
case 5:
isoverflow();
break;
case 6:
 display();
break;
case 7:
exit(0);
default:
printf("INVALID CHOICE\n");
}
}
}
void push(int ele)
{
struct stack *newnode=NULL;
if(count==SIZE)
{
printf("stack is full.\n");
}
else
{
newnode=(struct stack*)malloc(sizeof(struct stack));
newnode->data=ele;
newnode->link=NULL;
if(top==NULL || count==0)
{
top=newnode;
printf("%d pushed successfully.\n",ele);
count++;
}
else
{
newnode->link=top;
top=newnode;
count++;
}
}
}
void pop()
{
if(top==NULL||count==0)
{
printf("Stack is empty.\n");
}
else
{
struct stack *todel=NULL;
todel=top;
top=top->link;
printf("%d popped.\n",todel->data);
todel->link=NULL;
 free(todel);
count--;
}
}
void peek()
{
if (top == NULL||count==0)
{
printf("Stack is empty.\n");
}
else
{
printf("Top element: %d\n",top->data);
}
}
void isunderflow()
{
if (top == NULL)
{
printf("Stack is underflowing (empty).\n");
}
else
{
printf("Stack is not underflowing.\n");
}
}

void isoverflow()
{
if (count == SIZE)
{
printf("Stack is overflowing (full).\n");
}
else
{
printf("Stack is not overflowing.\n");
}
}
void display()
{
if (top == NULL)
{
printf("Stack is empty.\n");
}
else
{
struct stack *temp = top;
printf("Stack elements:\n");
 while (temp != NULL)
{
printf("%d\n", temp->data);
temp = temp->link;
}
}
}
15)Write a C program to evaluate a postfix expression
========================================
#include<stdio.h>
#include<string.h>
#define SIZE 10
void push(int);
int pop();
int top=-1;
int stack[SIZE];
void main()
{
int n1,n2,res,i;
char exp[50],operation;
printf("Enter the expression:");
scanf("%s",exp);
int n=strlen(exp);
for(int i=0;i<n;i++)
{
if(exp[i]>='0' &&exp[i]<='9')
{
int digit=exp[i]-'0';
push(digit);
}
else
{
operation=exp[i];
n1=pop();
n2=pop();
if(operation=='+')
{
res=n2+n1;
}
else if(operation=='-')
{
res=n2-n1;
}
else if(operation=='*')
{
res=n2*n1;
}
else
 {
res=n2/n1;
}
push(res);
}
}
printf("The postfix expression %s is result is %d.",exp,stack[top]);
}
void push(int ele)
{
top++;
stack[top]=ele;
}
int pop()
{
return stack[top--];
}
16)Write a C program to convert infix to postfix
====================================

#include <stdio.h>
#include <string.h>
#include <ctype.h>

#define MAX 50

char stack[MAX];
int top = -1;

void push(char);
char pop();
int priority(char);

void main()
{
char exp[20];
printf("Enter an infix expression: ");
scanf("%s", exp);

int n = strlen(exp);

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

{
if (isalnum(exp[i]))
{
printf("%c", exp[i]);
}
else if (exp[i] == '(')
 {
push(exp[i]);
}
else if (exp[i] == ')')
{
char x = pop();
while (x != '(')
{
printf("%c", x);
x = pop();
}
}
else
{
while (top != -1 && priority(stack[top]) >= priority(exp[i]))
{
printf("%c", pop());
}
push(exp[i]);
}
}

while (top != -1)

{
printf("%c", pop());
}
printf("\n");
}

void push(char x)
{
if (top == MAX - 1)
{
printf("Stack Overflow\n");
return;
}
stack[++top] = x;
}

char pop()
{
if (top == -1)
{
printf("Stack Underflow\n");
return -1;
}
return stack[top--];
}
int priority(char x)
{
if (x == '+' || x == '-')
{
return 1;
}
if (x == '*' || x == '/')
{
return 2;
}
return 0;
}
17)Write a C program to reverse the list of elements using a stack
=================================================
#include<stdio.h>

#define SIZE 10
int stack[SIZE];
void reverse(int[],int);
void main()
{
int a[10],n;
printf("How many elements do you want in the array:");
scanf("%d",&n);
printf("Enter array elements\n");
for(int i=0;i<n;i++)
{
printf("Enter element %d:",i+1);
scanf("%d",&a[i]);
}
printf("array elements before reversing\n");
for(int i=0;i<n;i++)
{
printf("%d\n",a[i]);
}
reverse(a,n);
printf("array elements after reversing\n");
for(int i=0;i<n;i++)
{
printf("%d\n",a[i]);
}
}
void reverse(int a[],int n)
{
int top=-1;
for(int i=0;i<n;i++)
{
 top++;
stack[top]=a[i];
}
for(int i=0;i<n;i++)
{
a[i]=stack[top];
top--;
}
}
18)Write a C program to check if the given string is a palindrome or not.
=====================================================
#include <stdio.h>
#include<string.h>
char stack[10];
int top=-1;
void reverse(char[],int);
void main()
{
char a[]="madam";
int n=strlen(a);
int i;
printf("String before reversing:");
for(i=0;i<n;i++)
{
printf("%c ",a[i]);
}
printf("\n");
reverse(a,n);
printf("String after reversing:");
for(i=0;i<n;i++)
{
printf("%c ",a[i]);
}
printf("\n");
if(strcmp(a,stack)==0)
{
printf("Yes it is a palindrome.");
}
else
{
printf("No it is not a palindrome.");
}
}
void reverse(char a[],int n)
{
int i;
for(i=0;i<n;i++)
{
 top++;
stack[top]=a[i];
}
for(i=0;i<n;i++)
{
a[i]=stack[top];
top--;
}
}
19)Write a C program to implement Balancing parantheses program.
===================================================
#include <stdio.h>
#include<string.h>
char stack[20];
int top=-1;
void push(char);
void pop();
void main()
{
char exp[10];
int i,n;
printf("Enter the expression:");
scanf("%s",exp);
n=strlen(exp);
for(i=0;i<n;i++)
{
if(exp[i]=='('||exp[i]=='{'||exp[i]=='[')
{
push(exp[i]);
}
else if(exp[i]==')'||exp[i]=='}'||exp[i]==']')
{
if(exp[i]==')')
{
if(stack[top]=='(')
{
pop();
}
else
{
break;
}
}
if(exp[i]=='}')
{
if(stack[top]=='{')
{
pop();
 }
else
{
break;
}
}
if(exp[i]==']')
{
if(stack[top]=='[')
{
pop();
}
else
{
break;
}
}
}

}
if(top==-1)
{
printf("Balanced expression.\n");
}
else
{
printf("Unbalanced expression.\n");
}
}
void push(char x)
{
top++;
stack[top]=x;
}
void pop()
{
top--;
}
20)Write a C program to implement Backtracking ideology.
============================================
#include <stdio.h>
#define SIZE 10
int stack[SIZE];
int top=-1;
void push(int);
void pop();
int validate(int);
void stackprint();
void main()
{
int i;
for(i=1;i<=5;i++)
{
if(validate(i))
{
push(i);
printf("%d Valid move...\n",i);
stackprint();
printf("\n");
}
else
{
printf("%d Dead end.Backtracking\n",i);
if(top != -1)
pop();
}
}
}
void push(int x)
{
top++;
stack[top]=x;
}
void pop()
{
top--;
}
int validate(int i)
{
return(i!=2 && i!=3);
}
void stackprint()
{
for(int i=0;i<=top;i++)
{
printf("%d\n",stack[i]);
}
printf("\n");
}
21)Write a C program to implement queue operations using arrays.
===================================================
#include<stdio.h>
#include<stdlib.h>
#define SIZE 15
int queue[SIZE];
void enqueue(int);
void dequeue();
void peek();
void isfull();
void isempty();
void display();
int front=-1;
int rear=-1;
void main()
{
int ele,ch;
while(1)
{
printf("\n1.Enqueue\n2.Dequeue\n3.Peek\n4.Isempty\n5.Isfull\n6.Display\n7.Exit\n");
printf("Please enter your choice:");
scanf("%d",&ch);
switch(ch)
{
case 1:
printf("Enter element:");
scanf("%d",&ele);
enqueue(ele);
break;
case 2:
dequeue();
break;
case 3:
peek();
break;
case 4:
isempty();
break;
case 5:
isfull();
break;
case 6:
display();
break;
case 7:
exit(0);
default:
printf("INVALID CHOICE\n");
}
}
}
void enqueue(int ele)
{
if(rear==SIZE-1)
 {
printf("Queue is full.\n");
}
else if(front==-1&&rear==-1)
{
front++;
rear++;
queue[rear]=ele;
printf("%d inserted.\n",ele);
}
else
{
rear++;
queue[rear]=ele;
printf("%d inserted.\n",ele);
}
}
void dequeue()
{
if(front==-1 && rear==-1)
{
printf("Queue is empty.\n");
}
else if(front==rear)
{
printf("%d deleted.\n",queue[front]);
front=-1;
rear=-1;
}
else
{
printf("%d deleted.\n",queue[front]);
front++;
}
}
void peek()
{
if(front==-1 && rear==-1)
{
printf("Queue is empty.\n");
}
else
{
printf("%d is the peeked value.\n",queue[front]);
}
}
void isempty()
{
 if(front==-1 && rear==-1)
{
printf("Yes,queue is empty.\n");
}
else
{
printf("No,queue is not empty.\n");
}
}
void isfull()
{
if(rear==SIZE-1)
{
printf("Yes, queue is full.\n");
}
else
{
printf("No, queue is not full\n.");
}
}
void display()
{
if(front==-1 && rear==-1)
{
printf("Queue is empty.\n");
}
else
{
for(int i=front;i<=rear;i++)
{
printf("%d ",queue[i]);
}
printf("\n");
}
}
22)Write a C program to implement queue operations using linked lists.
=======================================================
#include<stdio.h>
#include<stdlib.h>
#define SIZE 15
struct queue
{
int data;
struct queue *link;
};
void enqueue(int);
void dequeue();
void peek();
void isfull();
void isempty();
void display();
struct queue *front=NULL;
struct queue *rear=NULL;
int count=0;
void main()
{
int ele,ch;
while(1)
{
printf("\n1.Enqueue\n2.Dequeue\n3.Peek\n4.Isempty\n5.Isfull\n6.Display\n7.Exit\n");
printf("Please enter your choice:");
scanf("%d",&ch);
switch(ch)
{
case 1:
printf("Enter element:");
scanf("%d",&ele);
enqueue(ele);
break;
case 2:
dequeue();
break;
case 3:
peek();
break;
case 4:
isempty();
break;
case 5:
isfull();
break;
case 6:
display();
break;
case 7:
exit(0);
default:
printf("INVALID CHOICE\n");
}
}
}
void enqueue(int ele)
{
struct queue *newnode=NULL;
if(count==SIZE)
{
 printf("Queue is full.\n");
}
else if((front==NULL && rear==NULL)||count==0)
{
newnode=(struct queue*)malloc(sizeof(struct queue));
newnode->data=ele;
newnode->link=NULL;
if(newnode==NULL)
{
printf("Memory not allocated.\n");
}
front=newnode;
rear=newnode;
count++;
printf("%d inserted.",ele);
}
else
{
newnode=(struct queue*)malloc(sizeof(struct queue));
newnode->data=ele;
newnode->link=NULL;
rear->link=newnode;
rear=newnode;
count++;
printf("%d inserted.\n",ele);
}
}
void dequeue()
{
if((front==NULL&&rear==NULL)||count==0)
{
printf("Queue is empty.\n");
}
else if(front==rear)
{
printf("%d deleted.",front->data);
front=NULL;
rear=NULL;
count--;
}
else
{
struct queue *todel=NULL;
todel=front;
front=front->link;
todel->link=NULL;
printf("%d deleted.\n",todel->data);
free(todel);
 count--;
}
}
void peek()
{
if((front==NULL&&rear==NULL)||count==0)
{
printf("Queue is empty.\n");
}
else
{
printf("%d is peeked value.\n",front->data);
}
}
void isempty()
{
if(front==NULL && rear==NULL)
{
printf("Yes,queue is empty.\n");
}
else
{
printf("No,queue is not empty.\n");
}
}
void isfull()
{
if(count==SIZE)
{
printf("Yes, queue is full.\n");
}
else
{
printf("No, queue is not full.\n");
}
}
void display()
{
if(front==NULL && rear==NULL)
{
printf("Queue is empty.\n");
}
else
{
struct queue *temp=NULL;
temp=front;
while(temp!=NULL)
{
 printf("%d ",temp->data);
temp=temp->link;
}
}
}
23)Write a C program to implement circular queue.
=======================================
#include<stdio.h>
#include<stdlib.h>
#define SIZE 15
int queue[SIZE];
void enqueue(int);
void dequeue();
void peek();
void isfull();
void isempty();
void display();
int front=-1;
int rear=-1;
void main()
{
int ele,ch;
while(1)
{
printf("\n1.Enqueue\n2.Dequeue\n3.Peek\n4.Isempty\n5.Isfull\n6.Display\n7.Exit\n");
printf("Please enter your choice:");
scanf("%d",&ch);
switch(ch)
{
case 1:
printf("Enter element:");
scanf("%d",&ele);
enqueue(ele);
break;
case 2:
dequeue();
break;
case 3:
peek();
break;
case 4:
isempty();
break;
case 5:
isfull();
break;
case 6:
display();
 break;
case 7:
exit(0);
default:
printf("INVALID CHOICE\n");
}
}
}
void enqueue(int ele)
{
if((rear+1)%SIZE==front)
{
printf("Queue is full.\n");
}
else if(front==-1&&rear==-1)
{
front++;
rear++;
queue[rear]=ele;
printf("%d inserted.\n",ele);
}
else
{
rear=(rear+1)%SIZE;
queue[rear]=ele;
printf("%d inserted.\n",ele);
}
}
void dequeue()
{
if(front==-1 && rear==-1)
{
printf("Queue is empty.\n");
}
else if(front==rear)
{
printf("%d deleted.\n",queue[front]);
front=-1;
rear=-1;
}
else
{
printf("%d deleted.\n",queue[front]);
front=(front+1)%SIZE;
}
}
void peek()
{
 if(front==-1 && rear==-1)
{
printf("Queue is empty.\n");
}
else
{
printf("%d is the peeked value.\n",queue[front]);
}
}
void isempty()
{
if(front==-1 && rear==-1)
{
printf("Yes,queue is empty.\n");
}
else
{
printf("No,queue is not empty.\n");
}
}
void isfull()
{
if((rear+1)%SIZE==front)
{
printf("Yes, queue is full.\n");
}
else
{
printf("No, queue is not full\n.");
}
}
void display()
{
if(front==-1 && rear==-1)
{
printf("Queue is empty.\n");
}
else
{
int i=front;
while(i!=rear)
{
printf("%d ",queue[i]);
i=(i+1)%SIZE;
}
printf("%d ",queue[rear]);
}
}
24)Write a C program to implement Double Ended Queue(Deque)
==================================================
#include<stdio.h>
#include<stdlib.h>
#define SIZE 15
int queue[SIZE];
void insert_at_front(int);
void insert_at_rear(int);
void del_at_front();
void del_at_rear();
void peek();
void isfull();
void isempty();
void display();
int front=-1;
int rear=-1;
void main()
{
int ele,ch;
while(1)
{
printf("\n1. Insert at Front\n2. Insert at Rear\n3. Delete from Front\n4. Delete from
Rear\n");
printf("5. Peek (Front)\n6. Is Empty\n7. Is Full\n8. Display\n9. Exit\n");
printf("Please enter your choice: ");
scanf("%d", &ch);
switch(ch)
{
case 1:
printf("Enter element: ");
scanf("%d", &ele);
insert_at_front(ele);
break;
case 2:
printf("Enter element: ");
scanf("%d", &ele);
insert_at_rear(ele);
break;
case 3:
del_at_front();
break;
case 4:
del_at_rear();
break;
case 5:
peek();
break;
case 6:
 isempty();
break;
case 7:
isfull();
break;
case 8:
display();
break;
case 9:
exit(0);
default:
printf("INVALID CHOICE\n");
}
}
}
void insert_at_front(int ele)
{
if((rear+1)%SIZE==front)
{
printf("Queue is full.\n");
}
else if(front==-1&&rear==-1)
{
front++;
rear++;
queue[front]=ele;
printf("%d inserted.\n",ele);
}
else if(front==0)
{
front=SIZE-1;
queue[front]=ele;
printf("%d inserted.\n",ele);
}
else
{
front=(front-1)%SIZE;
queue[front]=ele;
printf("%d inserted.\n",ele);
}
}
void insert_at_rear(int ele)
{
if((rear+1)%SIZE==front)
{
printf("Queue is full.\n");
}
else if(front==-1&&rear==-1)
 {
front++;
rear++;
queue[rear]=ele;
printf("%d inserted.\n",ele);
}
else
{
rear=(rear+1)%SIZE;
queue[rear]=ele;
printf("%d inserted.\n",ele);
}
}
void del_at_front()
{
if(front==-1 && rear==-1)
{
printf("Queue is empty.\n");
}
else if(front==rear)
{
printf("%d deleted.\n",queue[front]);
front=-1;
rear=-1;
}
else
{
printf("%d deleted.\n",queue[front]);
front=(front+1)%SIZE;
}
}
void del_at_rear()
{
if(front==-1 && rear==-1)
{
printf("Queue is empty.\n");
}
else if(front==rear)
{
printf("%d deleted.\n",queue[front]);
front=-1;
rear=-1;
}
else if(rear==0)
{
printf("%d delete.\n",queue[rear]);
rear=SIZE-1;
}
 else
{
printf("%d deleted.\n",queue[rear]);
rear=(rear-1)%SIZE;
}
}
void peek()
{
if(front==-1 && rear==-1)
{
printf("Queue is empty.\n");
}
else
{
printf("%d is the peeked value.\n",queue[front]);
}
}
void isempty()
{
if(front==-1 && rear==-1)
{
printf("Yes,queue is empty.\n");
}
else
{
printf("No,queue is not empty.\n");
}
}
void isfull()
{
if((rear+1)%SIZE==front)
{
printf("Yes, queue is full.\n");
}
else
{
printf("No, queue is not full\n.");
}
}
void display()
{
if(front==-1 && rear==-1)
{
printf("Queue is empty.\n");
}
else
{
int i=front;
 while(i!=rear)
{
printf("%d ",queue[i]);
i=(i+1)%SIZE;
}
printf("%d ",queue[rear]);
}
}
25)Write a C program to implement BST(binary search tree).
==============================================
#include<stdio.h>
#include<stdlib.h>
struct node
{
int data;
struct node *left;
struct node *right;
};
struct node *root=NULL;
struct node* create(int);
struct node* insert(struct node*,int);
void preorder(struct node*);
void inorder(struct node*);
void postorder(struct node*);
void search(struct node*,int);
struct node* delete(struct node*,int);
struct node* inorder_successor(struct node *temp);
void main()
{
int i,n,ele,sele,choice,del;
while(1)
{
printf("\n1.insert 2.preorder 3.inorder 4.postorder 5.search 6.delete 7.exit\n");
printf("Enter the choice:");
scanf("%d",&choice);
switch(choice)
{
case 1:
printf("How many elements want:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("Enter the element %d:",i+1);
scanf("%d",&ele);
root=insert(root,ele);
}
break;
case 2:
 printf("\nThe elements in tree in preorder is:\n");
preorder(root);
break;
case 3:
printf("\nThe elements in tree in inorder is:\n");
inorder(root);
break;
case 4:
printf("\nThe elements in tree in postorder is:\n");
postorder(root);
break;
case 5:
printf("\nEnter the element to search:");
scanf("%d",&sele);
search(root,sele);
break;
case 6:
printf("Enter the element to delete:");
scanf("%d",&del);
root=delete(root,del);
break;
case 7:
exit(0);
break;
default:
printf("invalid choice\n");
}
}
}
struct node* delete(struct node *rt,int ele)
{

if(rt==NULL)
{
printf("deletion not possiable");
}
else if(ele<rt->data)
{
rt->left = delete(rt->left,ele);
}
else if(ele>rt->data)
{
rt->right = delete(rt->right,ele);
}
else
{
if(rt->left==NULL)
{
 struct node *temp=NULL;
temp=rt->right;
free(rt);
return temp;
}
else if(rt->right==NULL)
{
struct node *temp=NULL;
temp=rt->left;
free(rt);
return temp;
}
else
{
struct node *temp=NULL;
temp = inorder_successor(rt->right);
rt->data = temp->data;
rt->right = delete(rt->right,temp->data);
}
}
return rt;
}
struct node* inorder_successor(struct node *temp)
{
struct node *cur=NULL;
cur=temp;
while(cur->left!=NULL)
{
cur = cur->left;
}
return cur;
}
struct node* insert(struct node *rt,int ele)
{
if(rt==NULL)
{
rt=create(ele);
}
else if(ele<=rt->data)
{
rt->left = insert(rt->left,ele);
}
else
{
rt->right = insert(rt->right,ele);
}
return rt;
}
struct node* create(int ele)
{
struct node *newnode = NULL;
newnode = (struct node*)malloc(sizeof(struct node));
newnode->data = ele;
newnode->left=NULL;
newnode->right=NULL;
return newnode;
}
void preorder(struct node* rt)
{
if(rt!=NULL)
{
printf("%d ",rt->data);
preorder(rt->left);
preorder(rt->right);
}
}
void inorder(struct node* rt)
{
if(rt!=NULL)
{
inorder(rt->left);
printf("%d ",rt->data);
inorder(rt->right);
}
}
void postorder(struct node* rt)
{
if(rt!=NULL)
{
postorder(rt->left);
postorder(rt->right);
printf("%d ",rt->data);
}
}
void search(struct node* rt,int key)
{
if(rt==NULL)
{
printf("search not possiable");
}
else if(key==rt->data)
{
printf("%d found\n",key);
}
else if(key<rt->data)
{
 search(rt->left,key);
}
else
{
search(rt->right,key);
}
}
===============================END===================================