Data Structure - 629401

Prectical=8
Create a “Linked List” structure with the following data members:
1.A Data
2.A link to the next node
Perform the following operations on stack using user-defined functions:
1. Insert a value X at the first place
2. Insert a value X at the end of the list
3. Insert a value X at the place so that it preserves the ordering of the terms in the increasing
order.
i. Delete an element whose address is given by X
ii. Copy a linked linear list.
Code:
// Create Queue and performing its function
#include<stdio.h>
#include<stdlib.h>
struct node{
int data;
struct node *next;
};
struct node *head;
void beginsert ();
void lastinsert ();
void randominsert();
void begin_delete();
void last_delete();
void random_delete();
void display();
void writeToFile();
void search();
void main (){
int choice =0;
while(choice != 10)
{
printf("\nChoose any one option:\n");
printf("\n1.Insert at first");
printf("\n2.Insert at last");
printf("\n3.Insert at any random location");
printf("\n4.Delete from Beginning");
printf("\n5.Delete from last");
printf("\n6.Delete node after specified location");

ANIKET MOCHI - 2256906938

 Data Structure - 629401

printf("\n7.Search for an element");

printf("\n8.Show");
printf("\n9.Write file");
printf("\n10.Exit");
printf("\nEnter your choice?\n");
scanf("\n%d",&choice);
switch(choice)
{
case 1:
beginsert();
break;
case 2:
lastinsert();
break;
case 3:
randominsert();
break;
case 4:
begin_delete();
break;
case 5:
last_delete();
break;
case 6:
random_delete();
break;
case 7:
search();
break;
case 8:
display(head);
break;
case 9:
writeToFile();
break;
case 10:
exit(0);
break;
default:
printf("Please enter valid choice..");
}}}
void beginsert()

ANIKET MOCHI - 2256906938

 Data Structure - 629401

{
struct node *ptr;
int item;
ptr = (struct node *) malloc(sizeof(struct node *));
if(ptr == NULL){
printf("\nOVERFLOW");
}
else{
printf("\nEnter value\n");
scanf("%d",&item);
ptr->data = item;
ptr->next = head;
head = ptr;
printf("\nNode inserted");
}}
void lastinsert()
{
struct node *ptr,*temp;
int item;
ptr = (struct node*)malloc(sizeof(struct node));
if(ptr == NULL){
printf("\nOVERFLOW");
}
else{
printf("\nEnter value?\n");
scanf("%d",&item);
ptr->data = item;
if(head == NULL){
ptr -> next = NULL;
head = ptr;
printf("\nNode inserted");
}
else
{
temp = head;
while (temp -> next != NULL){
temp = temp -> next;
}
temp->next = ptr;
ptr->next = NULL;
printf("\nNode inserted");
}}}

ANIKET MOCHI - 2256906938

 Data Structure - 629401

void randominsert()
{
int i,loc,item;
struct node *ptr, *temp;
ptr = (struct node *) malloc (sizeof(struct node));
if(ptr == NULL){
printf("\nOVERFLOW");
}
Else
{
printf("\nEnter element value\n ");
scanf("%d",&item);
ptr->data = item;
printf("\nEnter the location after which you want to insert ");
scanf("\n%d",&loc);
temp=head;
for(i=0;i<loc;i++){
temp = temp->next;
if(temp == NULL){
printf("\ncan't insert\n");
return;
}}
ptr ->next = temp ->next;
temp ->next = ptr;
printf("\nNode inserted");
}}
void begin_delete()
{
struct node *ptr;
if(head == NULL){
printf("\nList is empty\n");
}
else
{
ptr = head;
head = ptr->next;
free(ptr);
printf("\nNode deleted from the begining ...\n");
}}
void last_delete()
{
struct node *ptr,*ptr1;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

if(head == NULL){
printf("\nlist is empty");
}
else if(head -> next == NULL){
head = NULL;
free(head);
printf("\nOnly node of the list deleted ...\n");
}
else{
ptr = head;
while(ptr->next != NULL){
ptr1 = ptr;
ptr = ptr ->next;
}
ptr1->next = NULL;
free(ptr);
printf("\nDeleted Node from the last ...\n");
}}
void random_delete()
{
struct node *ptr,*ptr1;
int loc,i;
printf("\n Enter the location of the node after which you want to perform deletion\n");
scanf("%d",&loc);
ptr=head;
for(i=0;i<loc;i++){
ptr1 = ptr;
ptr = ptr->next;
if(ptr == NULL){
printf("\nCan't delete");
return;
}}
ptr1 ->next = ptr ->next;
free(ptr);
printf("\nDeleted node %d ",loc+1);
}
void search(){
struct node *ptr;
int item,i=0,flag;
ptr = head;
if(ptr == NULL){
printf("\nEmpty List\n");

ANIKET MOCHI - 2256906938

 Data Structure - 629401

}
Else
{
printf("\nEnter item which you want to search?\n");
scanf("%d",&item);
while (ptr!=NULL){
if(ptr->data == item){
printf("item found at location %d ",i+1);
flag=0;
}
else{
flag=1;
}
i++;
ptr = ptr -> next;
}
if(flag==1)
{
printf("Item not found\n");
}}}
void display(struct node* head){
struct node *ptr = head;
if(ptr == NULL){
printf("Nothing to print");
}
Else
{
printf("Elements in a List:");
while (ptr!=NULL){
printf("\n%d",ptr->data);
ptr = ptr -> next;
}}}
void writeToFile(){
char *filename = "test.txt";
FILE *fp = fopen(filename, "w");
struct node *ptr;
ptr = head;
if(fp==NULL){
printf("Error\n");
}
else{
while(ptr!=NULL){

ANIKET MOCHI - 2256906938

 Data Structure - 629401

fprintf(fp, "\n %d", ptr->data);

ptr = ptr -> next;
}}
fclose(fp);
printf("File Created");
}
Output:

ANIKET MOCHI - 2256906938

 Data Structure - 629401

Prectical=9
Create a “Queue” structure with following Data members:
1. Integer Array
2. Size of the Array
Perform the following operations on Simple queue using user-defined functions: 1. Insert an
element
2. Remove an element
3. Display
4. Isfull
5. Isempty Create a file which stores all values of Array
Code
// Create Queue and performing its function
#include <stdio.h>
#define MAX 50
void insert();
void delete();
void display();
int queue_array[MAX];
int rear = - 1;
int front = - 1;
void main(){
int choice;
while (1)
{
printf("1.Insert \n");
printf("2.Delete\n");
printf("3.Display \n");
printf("4.Quit \n");
printf("Enter your choice : ");
scanf("%d", &choice);
switch (choice)
{
case 1:
insert();
break;
case 2:
delete();
break;
case 3:
display();

ANIKET MOCHI - 2256906938

 Data Structure - 629401

break;
case 4:
exit(1);
default:
printf("Wrong choice \n");
}}}
void insert(){
int add_item;
if (rear == MAX - 1)
{
printf("Queue Overflow \n");
}
else{
if (front == - 1)
front = 0;
printf("Insert the element in queue : ");
scanf("%d", &add_item);
rear = rear + 1;
queue_array[rear] = add_item;
}}
void delete()
{
if (front == - 1 || front > rear)
{
printf("Queue Underflow \n");
return ;
}
else{
printf("Element deleted from queue is : %d\n", queue_array[front]);
front = front + 1;
}}
void display()
{
int i;
if (front == - 1)
printf("Queue is empty \n");
else
{
printf("Queue is : \n");
for (i = front; i <= rear; i++)
printf("%d ", queue_array[i]);
printf("\n");

ANIKET MOCHI - 2256906938

 Data Structure - 629401

}}
Output:

ANIKET MOCHI - 2256906938

 Data Structure - 629401

Prectical=10
Create a “Queue” user-defined structure with the following data members:
1. A Data
2. A link to the next node
Perform the following operations on Simple queue using user-defined functions:
1. Insert an element
2. Remove an element
3. Display
4. Isfull
5. Isempty
Create a file which stores all values of list.
Code:
//Create user-defined Queue
#include<stdio.h>
struct node
{
int data;
struct node *next;
};
struct node *front;
struct node *rear;
void insert();
void delete();
void display();
void main ()
{
int choice;
while(choice != 4)
{
printf("\n1.Insert an element\n2.Delete an element\n3.Display thequeue\n4.Exit\n");
printf("\nEnter your choice?\n");
scanf("%d",& choice);
switch(choice)
{
case 1:
insert();
break;
case 2:

ANIKET MOCHI - 2256906938

 Data Structure - 629401

delete();
break;
case 3:
display();
break;
case 4:
exit(0);
break;
default:
printf("\nEnter valid choice??\n");
}}}
void insert()
{
struct node *ptr;
int item;
ptr = (struct node *) malloc (sizeof(struct node));
if(ptr == NULL)
{
printf("\nOVERFLOW\n");
return;
}
else
{
printf("\nEnter value?\n");
scanf("%d",&item);
ptr -> data = item;
if(front == NULL)
{
front = ptr;
rear = ptr;
front -> next = NULL;
rear -> next = NULL;
}
else
{
rear -> next = ptr;
rear = ptr;
rear->next = NULL;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

}}}
void delete ()
{
struct node *ptr;
if(front == NULL)
{
printf("\nUNDERFLOW\n");
return;
}
else
{
ptr = front;
front = front -> next;
free(ptr);
}
}
void display()
{
struct node *ptr;
ptr = front;
if(front == NULL)
{
printf("\nEmpty queue\n");
}
else
{
printf("\nValues are:\n");
while(ptr != NULL)
{
printf("\n%d\n",ptr -> data);
ptr = ptr -> next;
}}}
Output:

ANIKET MOCHI - 2256906938

 Data Structure - 629401

ANIKET MOCHI - 2256906938

 Data Structure - 629401

Prectical=11
Create a “Circular Queue” structure with following Data members:
1. Integer Array
2. Size of the Array
Perform the following operations on Circular queue using user-defined functions:
1. Insert an element
2. Remove an element
3. Display
4. Isfull
5. Isempty
Create a file which stores all values of Array.
// Create Queue and performing its function
#include<stdio.h>
# define MAX 5
int cqueue_arr[MAX];
int front = -1;
int rear = -1;
void insert(int item)
{
if((front == 0 && rear == MAX-1) || (front == rear+1))
{
printf("Queue Overflow n");
return;
}
if(front == -1)
{
front = 0;
rear = 0;
}
else
{
if(rear == MAX-1)
rear = 0;
else
rear = rear+1;
}
cqueue_arr[rear] = item ;
}
void deletion()
{

ANIKET MOCHI - 2256906938

 Data Structure - 629401

if(front == -1)
{
printf("Queue Underflown");
return ;
}
printf("Element deleted from queue is : %dn",cqueue_arr[front]);
if(front == rear)
{
front = -1;
rear=-1;
}
else
{
if(front == MAX-1)
front = 0;
else
front = front+1;
}
}
void display()
{
int front_pos = front,rear_pos = rear;
if(front == -1)
{
printf("Queue is empty\n");
return;
}
printf("Queue elements :\n");
if( front_pos <= rear_pos )
while(front_pos <= rear_pos)
{
printf("%d ",cqueue_arr[front_pos]);
front_pos++;
}
else
{
while(front_pos <= MAX-1)
{
printf("%d ",cqueue_arr[front_pos]);
front_pos++;
}
front_pos = 0;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

while(front_pos <= rear_pos)

{
printf("%d ",cqueue_arr[front_pos]);
front_pos++;
}
}
printf("\n");
}
int main()
{
int choice,item;
do
{
printf("\nChoose any one option:\n");
printf("\n1.Insert\n");
printf("2.Delete\n");
printf("3.Display\n");
printf("4.Quit\n");
printf("Enter your choice : ");
scanf("%d",&choice);
switch(choice)
{
case 1 :
printf("Input the element for insertion in queue : ");
scanf("%d", &item);
insert(item);
break;
case 2 :
deletion();
break;
case 3:
display();
break;
case 4:
break;
default:
printf("Wrong choicen");
}
}while(choice!=4);
return 0;
}
Output:

ANIKET MOCHI - 2256906938

 Data Structure - 629401

ANIKET MOCHI - 2256906938

 Data Structure - 629401

Prectical=12
Create a “Circular Queue” user-defined structure with the following data members:
1. A Data
2. A link to the next node
Perform the following operations on Circular queue using user-defined functions:
1. Insert an element
2. Remove an element
3. Display
4. Isfull
5. Isempty
Create a file which stores all values of list.
Code:
//Create user-define Circular Queue
#include<stdio.h>
#include<stdlib.h>
struct node
{
int data;
struct node* next;
};
struct node *f = NULL;
struct node *r = NULL;
void enqueue(int d){
struct node* n;
n = (struct node*)malloc(sizeof(struct node));
n->data = d;
n->next = NULL;
if((r==NULL)&&(f==NULL)){
f = r = n;
r->next = f;
}
else{
r->next = n;
r = n;
n->next = f;
}}
void dequeue(){
struct node* t;
t = f;
if((f==NULL)&&(r==NULL))

ANIKET MOCHI - 2256906938

 Data Structure - 629401

printf("\nQueue is Empty");
else if(f == r){
f = r = NULL;
free(t);
}
else
{
f = f->next;
r->next = f;
free(t);
}}
void print()
{ // Print the elements of Queue
struct node* t;
t = f;
if((f==NULL)&&(r==NULL))
printf("\nQueue is Empty");
else{
do
{
printf("\n%d",t->data);
t = t->next;
}while(t != f);
}}
int main(){
int opt,n,i,data;
printf("Enter Your Choice:-");
do
{
printf("\n\n1 Insert\n2 Display \n3 Delete \n0 for Exit\n");
printf("*********************\n");
printf("Enter your choice:");
scanf("%d",&opt);
switch(opt){
case 1:
printf("\nHow many data you want to enter?");
scanf("%d",&n);
printf("\nEnter your data:");
i=0;
while(i<n){
scanf("%d",&data);
enqueue(data);

ANIKET MOCHI - 2256906938

 Data Structure - 629401

i++;
}
break;
case 2:
print();
break;
case 3:
dequeue();
break;
case 0:
break;
default:
printf("\nIncorrect Choice");}}while(opt!=0);
return 0;
}
Output:

ANIKET MOCHI - 2256906938

 Data Structure - 629401

Program 13 : Create a user-defined “Linked List” structure with the following data members:
1. A Co-efficient 2. An Exponent 3. A link to the next node

Perform the following operations on Singly list using user-defined functions:

1. Create 2. Display 3. Addition

4. Multiplication

Create a file which stores all values of list.

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

struct node{

int coeff; int exp;

struct node *next;

} *head1 = NULL, *head2 = NULL, *head3 = NULL, *head4 = NULL, *temp, *ptr;

void create();

void makenode(int, int);

struct node *insertend(struct node *);

void display(struct node *);

struct node *addtwopoly(struct node *, struct node *, struct node *);

struct node *subtwopoly(struct node *, struct node *, struct node *);

struct node *multwopoly(struct node *, struct node *, struct node *);

struct node *dispose(struct node *);

int search(struct node *, int);

void main() {

int ch, coefficient, exponent;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

int listno;

while (1){

printf("\ntMenu");

printf("\n\t1.Create First Node.");

printf("\n\t2.Display First Node.");

printf("\n\t3.Create Second Node.");

printf("\n\t4.Display Second Node.");

printf("\n\t5.Add Two Node.");

printf("\n\t6.Display Result of Addition.");

printf("\n\t7.Subtract Two Node.");

printf("\n\t8.Display Result of Subtraction.");

printf("\n\t9.Multiply Two Node.");

printf("\n\t10.Display Result of Product.");

printf("\n\t11.Dispose List.");

printf("\n\t12.Exit");

printf("\n\n\tEnter your choice?");

scanf("%d", &ch);

switch (ch) {

case 1:

printf("\nGenerating first Node:");

printf("\nEnter coefficient?");

scanf("%d", &coefficient);

printf("\nEnter exponent?");

scanf("%d", &exponent);

makenode(coefficient, exponent);

ANIKET MOCHI - 2256906938

 Data Structure - 629401

head1 = insertend(head1);

break;

case 2:

display(head1);

break;

case 3:

printf("\nGenerating second Node:");

printf("\nEnter coefficient?");

scanf("%d", &coefficient);

printf("\nEnter exponent?");

scanf("%d", &exponent);

makenode(coefficient, exponent);

head2 = insertend(head2);

break;

case 4:

display(head2);

break;

case 5:

printf("\nDisposing result list.");

head3 = dispose(head3);

head3 = addtwopoly(head1, head2, head3);

printf("Addition successfully done !");

break;

case 6:

display(head3);

ANIKET MOCHI - 2256906938

 Data Structure - 629401

break;

case 7:

head3 = dispose(head3);

head3 = subtwopoly(head1, head2, head3);

printf("Subtraction successfully done !");

getch();

break;

case 8:

display(head3);

break;

case 9:

head3 = dispose(head3);

head4 = dispose(head4);

head4 = multwopoly(head1, head2, head3);

break;

case 10:

display(head4);

break;

case 11:

printf("Enter list number to dispose(1 to 4)?");

scanf("%d", &listno);

if (listno == 1)

head1 = dispose(head1);

else if (listno == 2)

head2 = dispose(head2);

ANIKET MOCHI - 2256906938

 Data Structure - 629401

else if (listno == 3)

head3 = dispose(head3);

else if (listno == 4)

head4 = dispose(head4);

else

printf("Invalid number specified.");

break;

case 12:

exit(0);

default:

printf("Invalid Choice !");

break;}}}

void create() {

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

if (ptr == NULL) {

printf("Memory Allocation Error !");

exit(1); } }

void makenode(int c, int e) {

create();

ptr->coeff = c;

ptr->exp = e;

ptr->next = NULL; }

struct node *insertend(struct node *head) {

if (head == NULL)

head = ptr;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

else { temp = head;

while (temp->next != NULL)

temp = temp->next;

temp->next = ptr; }

return head;}

void display(struct node *head) {

if (head == NULL)

printf("List is empty !");

else { temp = head;

while (temp != NULL) {

printf("(%d, %d)->", temp->coeff, temp->exp);

temp = temp->next; }

printf("bb "); }

getch(); }

struct node *addtwopoly(struct node *h1, struct node *h2, struct node *h3) {

struct node *temp1, *temp2, *temp3;

temp1 = h1;

temp2 = h2;

while (temp1 != NULL || temp2 != NULL) {

if (temp1->exp == temp2->exp) {

makenode(temp1->coeff + temp2->coeff, temp1->exp);

h3 = insertend(h3); }

else {

makenode(temp1->coeff, temp1->exp);

h3 = insertend(h3);

ANIKET MOCHI - 2256906938

 Data Structure - 629401

makenode(temp2->coeff, temp2->exp);

h3 = insertend(h3); }

temp1 = temp1->next;

temp2 = temp2->next; }

if (temp1 == NULL && temp2 != NULL) {

while (temp2 != NULL) {

makenode(temp2->coeff, temp2->exp);

h3 = insertend(h3);

temp2 = temp2->next; } }

if (temp2 == NULL && temp1 != NULL) {

while (temp1 != NULL) {

makenode(temp2->coeff, temp2->exp);

h3 = insertend(h3);

temp1 = temp1->next; } }

return h3;}

struct node *subtwopoly(struct node *h1, struct node *h2, struct node *h3) {

struct node *temp1, *temp2, *temp3;

temp1 = h1;

temp2 = h2;

while (temp1 != NULL || temp2 != NULL) {

if (temp1->exp == temp2->exp) {

makenode(temp1->coeff - temp2->coeff, temp1->exp);

h3 = insertend(h3); }

else {

makenode(temp1->coeff, temp1->exp);

ANIKET MOCHI - 2256906938

 Data Structure - 629401

h3 = insertend(h3);

makenode(-temp2->coeff, temp2->exp);

h3 = insertend(h3); }

temp1 = temp1->next;

temp2 = temp2->next;}

if (temp1 == NULL && temp2 != NULL) {

while (temp2 != NULL) {

makenode(temp2->coeff, temp2->exp);

h3 = insertend(h3);

temp2 = temp2->next; } }

if (temp2 == NULL && temp1 != NULL) {

while (temp1 != NULL) {

makenode(-temp2->coeff, temp2->exp);

h3 = insertend(h3);

temp1 = temp1->next; } }

return h3;}

struct node *multwopoly(struct node *h1, struct node *h2, struct node *h3) {

int res = 0;

struct node *temp1, *temp2, *temp3;

printf("\nDisplaying First Linked List: \n\t\t");

display(h1);

printf("\nDisplaying Second Linked List : \n\t\t");

display(h2);

temp1 = h1;

while (temp1 != NULL) { temp2 = h2;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

while (temp2 != NULL) {

makenode(temp1->coeff * temp2->coeff, temp1->exp + temp2->exp);

h3 = insertend(h3);

temp2 = temp2->next; }

temp1 = temp1->next;}

printf("\nDisplaying Initial Result of Product : \n\t\t");

display(h3);

getch();

temp1 = h3;

while (temp1 != NULL) { temp2 = temp1->next;

res = 0;

while (temp2 != NULL) { if (temp1->exp == temp2->exp)

res += temp2->coeff;

temp2 = temp2->next;}

if (search(head4, temp1->exp) == 1) {

makenode(res + temp1->coeff, temp1->exp);

head4 = insertend(head4);}

temp1 = temp1->next;}

return head4;}

int search(struct node *h, int val) {

struct node *tmp;

tmp = h;

while (tmp != NULL) {

if (tmp->exp == val)

return 0;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

tmp = tmp->next; }

return 1;}

struct node *dispose(struct node *list) {

if (list == NULL) { printf("List is already empty.");

return list;}

else {temp = list;

while (list != NULL) { free(temp);

list = list->next;

temp = list; }

return list;} }

OUTPUT :

ANIKET MOCHI - 2256906938

 Data Structure - 629401

Program 14 : Create a user-defined structure with the following data members:

1. A Data 2. A link to the next node

Perform the following operations on list using user-defined functions:

1. Create a list 2. Traverse the whole list\ 3. Delete first node

4. Delete last node 5. Delete a node before specified data 6. Insert at first
position

7. Insert at last position 8. Insert a node before specified data 9. Insert a node at
specified position

10. Count 11. Copy 12. Merge two list

13. Reverse 14. Search 15. Sort

Create a file which stores all values of list.

#include<stdio.h>

#include<stdlib.h>

struct queue{

int data;

struct queue *next; };

typedef struct queue node;

node *start=NULL,*rear=NULL;

int choice,i;

void create(){

node *temp;

printf("\nCreating List\nEnter Data (Enter -1 to stop)...\n");

scanf("%d",&i);

while(i!=-1){

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

ANIKET MOCHI - 2256906938

 Data Structure - 629401

temp->next=NULL;

temp->data=i;

if(start==NULL){

start=temp;

rear=temp }

else{

rear->next=temp;

rear=temp; }

scanf("%d",&i); }

printf("\n-1 encountered\n"); }

void traverse(){

node *temp;

if(start==NULL){

printf("\nCreate A LIST first...");

create(); }

else{ temp=start;

printf("\nThe list as below\n");

while(temp->next!=NULL){

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

temp=temp->next; }

printf(" %d",temp->data); } }

void delete_first(){

node *temp;

if(start==NULL){ printf("\nThere is no list created\n"); }

else{ temp=start;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

start=start->next;

printf("\nDeleted element is %d\n",temp->data);

free(temp); } }

void delete_last() {

node *temp;

if(start==NULL){

printf("\nThere is no list created\n"); }

else{ temp=start;

while(temp->next!=NULL){

rear=temp;

temp=temp->next; }

rear->next=NULL;

printf("\nDeleted element is %d\n",temp->data);

free(temp); } }

void delete_before(){

node *temp,*prev;

int flag=0,count=0;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

printf("\nEnter value before to be deleted\n");

scanf("%d",&i);

temp=start;

while (temp!=NULL){

count++;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

if(temp->data==i){

flag=1;

break; }

temp=temp->next; }

if(flag==1){ if(count==1){ printf("Cannot delete before element of %d\n",i); }

else if(count==2){

temp=start;

start=start->next;

free(temp); }

else{ temp=start;

while(temp!=NULL){ prev=temp;

temp=temp->next;

if(temp->next->data==i){

prev->next=temp->next;

free(temp);

break; } } } }

else{ printf("\nValue is not found\n"); } }

void insert_first() {

node *temp;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

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

printf("Enter value to insert: ");

scanf("%d",&i);

ANIKET MOCHI - 2256906938

 Data Structure - 629401

temp->data=i;

temp->next=start;

start=temp; }

void insert_last(){

node *temp;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

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

printf("Enter value to insert: ");

scanf("%d",&i);

temp->data=i;

temp->next=NULL;

rear->next=temp;

rear=temp; }

void insert_before() {

node *temp,*trav,*prev;

int val,flag=0,count=0;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

printf("Enter before value to insert: ");

scanf("%d",&val);

temp=start;

while (temp!=NULL){

ANIKET MOCHI - 2256906938

 Data Structure - 629401

count++;

if(temp->data==val){

flag=1;

break; }

temp=temp->next; }

if(flag==1){

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

printf("Enter value to insert: ");

scanf("%d",&i);

temp->data=i;

temp->next=NULL;

if(count==1){

temp->next=start;

start=temp; }

else{

trav=start;

while(trav!=NULL){

prev=trav;

trav=trav->next;

if(trav->data==val){

prev->next=temp;

temp->next=trav;

break; } } } }

else{ printf("\nValue is not found\n"); } }

void insert_specified(){

ANIKET MOCHI - 2256906938

 Data Structure - 629401

node *temp,*trav,*prev;

int val,flag=0,count=0;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

printf("Enter position to insert: ");

scanf("%d",&val);

val--;

if(val<1){

insert_first(); }

else{

trav=start;

while(count!=val && trav->next!=NULL){

count++;

prev=trav;

trav=trav->next; }

if(count==val){

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

printf("Enter value to insert: ");

scanf("%d",&i);

temp->data=i;

temp->next=trav;

prev->next=temp; }

else{ insert_last(); } } }

void count(){

ANIKET MOCHI - 2256906938

 Data Structure - 629401

node *temp;

int count=0;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

temp=start;

while(temp!=NULL){

count++;

temp=temp->next; }

printf("\nTotal Nodes: %d\n",count); }

void reverse_list(){

node *temp;

int count=0,*rev_array;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

temp=start;

while(temp!=NULL){

count++;

temp=temp->next; }

rev_array=(int *)malloc(count*sizeof(int));

temp=start;

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

*(rev_array+i)=temp->data;

temp=temp->next; }

ANIKET MOCHI - 2256906938

 Data Structure - 629401

temp=start;

for(i=count-1;i>=0;i--){

temp->data=*(rev_array+i);

rear=temp;

temp=temp->next; } }

void search(){

node *temp;

int count=0,flag=0,val;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

printf("Enter value to search: ");

scanf("%d",&val);

temp=start;

while(temp!=NULL){

count++;

if(val==temp->data){

flag=1;

break; }

temp=temp->next; }

if(flag==0){

printf("Entered value is not found...\n"); }

else{ printf("%d is found at position: %d\n",val,count); } }

void sort_list(){

node *temp,*temp2;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

int temp3;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

temp=start;

while(temp!=NULL){

temp2=temp->next;

while(temp2!=NULL){

if(temp2->data<temp->data){

temp3=temp2->data;

temp2->data=temp->data;

temp->data=temp3; }

temp2=temp2->next; }

temp=temp->next; } }

void save() { node *temp;

if(start!=NULL) {

FILE *fptr;

fptr = fopen("custom_list.txt","w");

if(fptr == NULL) { printf("Error in file!");

exit(0); }

temp=start;

while(temp->next!=NULL) {

fprintf(fptr," %d -> ",temp->data);

temp = temp->next; }

fprintf(fptr," %d",temp->data);

ANIKET MOCHI - 2256906938

 Data Structure - 629401

printf("\n File is saved");

fclose(fptr); }

else { printf("\n The Queue is empty"); } }

int main() {

do { printf("\n\t PERFORMING OPERATIONS USING LINKED LIST");

printf("\n\t ");

printf("\n\t 1. Create a list\n\t 2. Traverse the whole list\n\t 3. Delete first node\n\t 4. Delete last
node\n\t 5. Delete a node before specified data\n\t 6. Insert at first position\n\t 7. Insert at last
position\n\t 8. Insert a node before specified data\n\t 9. Insert a node at specified position\n\t 10.
Count\n\t 11. Copy (NOT DONE YET)\n\t 12. Merge two list (NOT DONE YET)\n\t 13. Reverse\n\t 14.
Search\n\t 15. Sort\n\t 16. Save\n\t 17. Exit");

printf("\n Enter the Choice:");

scanf("%d",&choice);

switch(choice) {

case 1: { create(); break; }

case 2: { traverse(); break; }

case 3: { delete_first(); break; }

case 4: { delete_last(); break; }

case 5: { delete_before(); break; }

case 6: { insert_first(); break; }

case 7: { insert_last(); break; }

case 8: { insert_before(); break; }

case 9: { insert_specified(); break; }

case 10: { count(); break; }

case 11: { break; }

case 12: { break; }

case 13: { reverse_list(); break; }

ANIKET MOCHI - 2256906938

 Data Structure - 629401

case 14: { search(); break; }

case 15: { sort_list(); break; }

case 16: { save(); break; }

case 17: { printf("\nExit point...\n"); break; }

default: { printf ("\n\t Please Enter a Valid Choice(1 to 17)”); } }}

while(choice!=17);

return 0; }

Output :

ANIKET MOCHI - 2256906938

 Data Structure - 629401

Program 15 : Create a user-defined structure with the following data members:

1. A Data 2. A link to the next node

Perform the following operations on Circular list using user-defined functions:

1. Create a list 2. Traverse the whole list 3. Delete first node

4. Delete last node 5. Delete a node before specified data 6. Insert at first position

7. Insert at last position 8. Insert a node before specified data 9. Insert a node at specified
position

10. Count 11. Copy 12. Merge two list

13. Reverse 14. Search 15. Sort

Create a file which stores all values of list.

#include <stdio.h>

#include <stdlib.h>

struct queue { int data;

struct queue *next; };

typedef struct queue node;

node *start = NULL, *rear = NULL;

int choice, i;

void create() {

node *temp;

printf("\nCreating List\nEnter Data (Enter -1 to stop)...\n");

scanf("%d", &i);

while (i != -1) {

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

temp->next = NULL;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

temp->data = i;

if (start == NULL) {

start = temp;

rear = temp; }

else { rear->next = temp;

rear = temp;

rear->next = start; }

scanf("%d", &i); }

printf("\n-1 encountered\n"); }

void traverse() {

node *temp;

if (start == NULL) {

printf("\nCreate A LIST first...");

create(); }

else { temp = start;

while (temp->next->data != start->data) {

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

temp = temp->next; }

printf(" %d", temp->data);} }

void delete_first() {

node *temp;

if (start == NULL) { printf("\nThere is no list created\n"); }

else { temp = start;

start = start->next;

rear->next = start;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

printf("\nDeleted element is %d\n", temp->data);

free(temp); } }

void delete_last() {

node *temp, *prev;

if (start == NULL) { printf("\nThere is no list created\n"); }

else { temp = start;

while (temp->next->data != start->data) {

rear = temp;

temp = temp->next; }

rear->next = start;

printf("\nDeleted element is %d\n", temp->data);

free(temp); } }

void delete_before() {

node *temp, *prev;

int flag = 0, count = 0;

if (start == NULL) {

printf("\nThere is no list created\n");

return; }

printf("\nEnter value before to be deleted\n");

scanf("%d", &i);

temp = start;

do { count++;

if (temp->data == i) {

flag = 1;

break; }

ANIKET MOCHI - 2256906938

 Data Structure - 629401

temp = temp->next;

} while (temp->data != start->data);

if (flag == 1) {

if (count == 1) { printf("Cannot delete before element of %d\n", i); }

else if (count == 2) {

temp = start;

start = start->next;

rear->next = start;

free(temp); }

else { temp = start;

do { prev = temp;

temp = temp->next;

if (temp->next->data == i) {

prev->next = temp->next;

free(temp);

break; }

} while (temp->data != start->data); } }

else { printf("\nValue is not found\n"); } }

void insert_first() {

node *temp;

if (start == NULL) {

printf("\nThere is no list created\n");

return; }

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

printf("Enter value to insert: ");

ANIKET MOCHI - 2256906938

 Data Structure - 629401

scanf("%d", &i);

temp->data = i;

temp->next = start;

start = temp;

rear->next = start; }

void insert_last() {

node *temp;

if (start == NULL) {

printf("\nThere is no list created\n");

return; }

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

printf("Enter value to insert: ");

scanf("%d", &i);

temp->data = i;

temp->next = start;

rear->next = temp;

rear = temp; }

void insert_before() {

node *temp, *trav, *prev;

int val, flag = 0, count = 0;

if (start == NULL) {

printf("\nThere is no list created\n");

return; }

printf("Enter before value to insert: ");

scanf("%d", &val);

ANIKET MOCHI - 2256906938

 Data Structure - 629401

temp = start;

do { count++;

if (temp->data == val) {

flag = 1;

break; }

temp = temp->next;

} while (temp->data != start->data);

if (flag == 1) {

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

printf("Enter value to insert: ");

scanf("%d", &i);

temp->data = i;

temp->next = NULL;

if (count == 1) { temp->next = start;

start = temp;

rear->next = start; }

else { trav = start;

do {

prev = trav;

trav = trav->next;

if (trav->data == val) {

prev->next = temp;

temp->next = trav;

break; }

} while (trav->data != start->data); } }

ANIKET MOCHI - 2256906938

 Data Structure - 629401

else { printf("\nValue is not found\n"); } }

void insert_specified() {

node *temp, *trav, *prev;

int val, flag = 0, count = 0;

if (start == NULL) {

printf("\nThere is no list created\n");

return; }

printf("Enter position to insert: ");

scanf("%d", &val);

val--;

if (val < 1) { insert_first(); }

else { trav = start;

while (count != val && trav->next->data != start->data) {

count++;

prev = trav;

trav = trav->next; }

if (count == val) {

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

printf("Enter value to insert: ");

scanf("%d", &i);

temp->data = i;

temp->next = trav;

prev->next = temp; }

else { insert_last(); } } }

void count() {

ANIKET MOCHI - 2256906938

 Data Structure - 629401

node *temp;

int count = 0;

if (start == NULL) { printf("\nThere is no list created\n");

return; }

temp = start;

do { count++;

temp = temp->next;

} while (temp->data != start->data);

printf("\nTotal Nodes: %d\n", count); }

void reverse_list() { node *temp;

int count = 0, *rev_array;

if (start == NULL) {

printf("\nThere is no list created\n");

return; }

temp = start;

do { count++;

temp = temp->next;

} while (temp->data != start->data);

rev_array = (int *)malloc(count * sizeof(int));

temp = start;

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

*(rev_array + i) = temp->data;

temp = temp->next; }

temp = start;

for (i = count - 1; i >= 0; i--) {

ANIKET MOCHI - 2256906938

 Data Structure - 629401

temp->data = *(rev_array + i);

rear = temp;

temp = temp->next; } }

void search() { node *temp;

int count = 0, flag = 0, val;

if (start == NULL) {

printf("\nThere is no list created\n");

return; }

printf("Enter value to search: ");

scanf("%d", &val);

temp = start;

do { count++;

if (val == temp->data) {

flag = 1;

break; }

temp = temp->next;

} while (temp->data != start->data);

if (flag == 0) { printf("Entered value is not found...\n"); }

else { printf("%d is found at position: %d\n", val, count); } }

void sort_list() { node *temp, *temp2;

int temp3;

if (start == NULL) { printf("\nThere is no list created\n");

return; }

temp = start;

do { temp2 = temp->next;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

while (temp2->data != start->data) {

if (temp2->data < temp->data) {

temp3 = temp2->data;

temp2->data = temp->data;

temp->data = temp3; }

temp2 = temp2->next; }

temp = temp->next;

} while (temp->data != start->data); }

void save() { node *temp;

if (start != NULL) {

FILE *fptr;

fptr = fopen("custom_circular_list.txt", "w");

if (fptr == NULL) {

printf("Error in file!");

exit(0); }

temp = start;

while (temp->next->data != start->data) {

fprintf(fptr, " %d -> ", temp->data);

temp = temp->next; }

fprintf(fptr, " %d", temp->data);

printf("\n File is saved");

fclose(fptr); }

else { printf("\n The Queue is empty"); } }

int main() { do {

printf("\n\t PERFORMING OPERATIONS USING LINKED LIST");

ANIKET MOCHI - 2256906938

 Data Structure - 629401

printf("\n\t ");

printf("\n\t 1. Create a list\n\t 2. Traverse the whole list\n\t 3. Delete first node\n\t 4. Delete last
node\n\t 5. Delete a node before specified data\n\t 6. Insert at first position\n\t 7. Insert at last
position\n\t 8. Insert a node before specified data\n\t 9. Insert a node at specified position\n\t 10.
Count\n\t 11. Copy (NOT DONE YET)\n\t 12. Merge two list (NOT DONE YET)\n\t 13. Reverse\n\t 14.
Search\n\t 15. Sort\n\t 16. Save\n\t 17. Exit");

printf("\n Enter the Choice:");

scanf("%d", &choice);

switch (choice) {

case 1: { create(); break; }

case 2: { traverse(); break; }

case 3: { delete_first(); break; }

case 4: { delete_last(); break; }

case 5: { delete_before(); break; }

case 6: { insert_first(); break; }

case 7: { insert_last(); break; }

case 8: { insert_before(); break; }

case 9: { insert_specified(); break; }

case 10: { count(); break; }

case 11: { break; }

case 12: { break; }

case 13: { reverse_list(); break; }

case 14: { search(); break; }

case 15: { sort_list(); break; }

case 16: { save(); break; }

case 17: { printf("\nExit point...\n"); break; }

default: { printf("\n\t Please Enter a Valid Choice(1 to 17)"); }

ANIKET MOCHI - 2256906938

 Data Structure - 629401

} } while (choice != 17); return 0; }

OUTPUT :

ANIKET MOCHI - 2256906938

 Data Structure - 629401

Program 16 : Create a user-defined structure with the following data members:

1. A Data 2. A link to the next node 3. A link to the previous
node

Perform the following operations on the doubly-linked list using user-defined functions:

1. Create a list 2. Traverse the whole list\ 3. Delete first node

4. Delete last node 5. Delete a node before specified data 6. Insert at first position

7. Insert at last position 8. Insert a node before specified data 9. Insert a node at
specified position

10. Count 11. Copy 12. Merge two list

13. Reverse 14. Search 15. Sort

Create a file which stores all values of list.

#include<stdio.h>

#include<stdlib.h>

struct queue{

struct queue *prev;

int data;

struct queue *next; };

typedef struct queue node;

node *start=NULL,*rear=NULL;

int choice,i;

void create() { node *temp;

printf("\nCreating List\nEnter Data (Enter -1 to stop)...\n");

scanf("%d",&i);

while(i!=-1){

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

ANIKET MOCHI - 2256906938

 Data Structure - 629401

temp->next=NULL;

temp->prev=NULL;

temp->data=i;

if(start==NULL){

start=temp;

rear=temp; }

else{ temp->prev=rear;

rear->next=temp;

rear=temp; }

scanf("%d",&i); }

printf("\n-1 encountered\n");}

void traverse() { node *temp;

if(start==NULL){

printf("\nCreate A LIST first...");

create(); }

else{ temp=start;

printf("\nThe list as below\n");

while(temp->next!=NULL){

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

temp=temp->next; }

printf(" %d",temp->data); } }

void delete_first(){ node *temp;

if(start==NULL){

printf("\nThere is no list created\n"); }

else{ temp=start;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

start=start->next;

start->prev=NULL;

printf("\nDeleted element is %d\n",temp->data);

free(temp); } }

void delete_last(){ node *temp;

if(start==NULL){

printf("\nThere is no list created\n"); }

else{ temp=start;

while(temp->next!=NULL){

rear=temp;

temp=temp->next; }

rear->next=NULL;

printf("\nDeleted element is %d\n",temp->data);

free(temp); } }

void delete_before(){

node *temp,*pre;

int flag=0,count=0;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

printf("\nEnter value before to be deleted\n");

scanf("%d",&i);

temp=start;

while (temp!=NULL){

count++;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

if(temp->data==i){

flag=1;

break; }

temp=temp->next; }

if(flag==1){ if(count==1){

printf("Cannot delete before element of %d\n",i); }

else if(count==2){ temp=start;

start=start->next;

start->prev=NULL;

free(temp); }

else{ temp=start;

while(temp!=NULL){

pre=temp;

temp=temp->next;

if(temp->next->data==i){ pre->next=temp->next;

temp->next->prev=pre;

free(temp);

break; } } } }

else{ printf("\nValue is not found\n"); }}

void insert_first(){

node *temp;

if(start==NULL){ printf("\nThere is no list created\n");

return; }

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

printf("Enter value to insert: ");

ANIKET MOCHI - 2256906938

 Data Structure - 629401

scanf("%d",&i);

temp->data=i;

temp->prev=NULL;

temp->next=start;

start->prev=temp;

start=temp; }

void insert_last() {

node *temp;

if(start==NULL){ printf("\nThere is no list created\n");

return; }

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

printf("Enter value to insert: ");

scanf("%d",&i);

temp->data=i;

temp->next=NULL;

rear->next=temp;

temp->prev=rear;

rear=temp; }

void insert_before() { node *temp,*trav,*pre;

int val,flag=0,count=0;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

printf("Enter before value to insert: ");

scanf("%d",&val);

ANIKET MOCHI - 2256906938

 Data Structure - 629401

temp=start;

while (temp!=NULL){ count++;

if(temp->data==val){

flag=1;

break; }

temp=temp->next; }

if(flag==1){ temp = (node*)malloc(sizeof(node));

printf("Enter value to insert: ");

scanf("%d",&i);

temp->data=i;

temp->next=NULL;

temp->prev=NULL;

if(count==1){ temp->next=start;

start->prev=temp;

start=temp; }

else{ trav=start;

while(trav!=NULL){

pre=trav;

trav=trav->next;

if(trav->data==val){

pre->next=temp;

temp->prev=pre;

temp->next=trav;

trav->prev=temp;

break; } } } }

ANIKET MOCHI - 2256906938

 Data Structure - 629401

else{ printf("\nValue is not found\n"); } }

void insert_specified(){

node *temp,*trav,*pre;

int val,flag=0,count=0;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

printf("Enter position to insert: ");

scanf("%d",&val);

val--;

if(val<1){ insert_first(); }

else{ trav=start;

while(count!=val && trav->next!=NULL){

count++;

pre=trav;

trav=trav->next; }

if(count==val){ temp = (node*)malloc(sizeof(node));

printf("Enter value to insert: ");

scanf("%d",&i);

temp->data=i;

temp->next=trav;

trav->prev=temp;

pre->next=temp;

temp->prev=pre; }

else{ insert_last(); } } }

ANIKET MOCHI - 2256906938

 Data Structure - 629401

void count(){

node *temp;

int count=0;

if(start==NULL){ printf("\nThere is no list created\n");

return; }

temp=start;

while(temp!=NULL){

count++;

temp=temp->next; }

printf("\nTotal Nodes: %d\n",count); }

void reverse_list() { node *temp;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

temp=rear;

while(temp->prev!=NULL){

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

temp=temp->prev; }

printf(" %d",temp->data); }

void search(){

node *temp;

int count=0,flag=0,val;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

ANIKET MOCHI - 2256906938

 Data Structure - 629401

printf("Enter value to search: ");

scanf("%d",&val);

temp=start;

while(temp!=NULL){

count++;

if(val==temp->data){

flag=1;

break; }

temp=temp->next; }

if(flag==0){ printf("Entered value is not found...\n"); }

else{ printf("%d is found at position: %d\n",val,count); } }

void sort_list(){ node *temp,*temp2;

int temp3;

if(start==NULL){ printf("\nThere is no list created\n");

return; }

temp=start;

while(temp!=NULL){

temp2=temp->next;

while(temp2!=NULL){

if(temp2->data<temp->data){

temp3=temp2->data;

temp2->data=temp->data;

temp->data=temp3; }

temp2=temp2->next; }

temp=temp->next; } }

ANIKET MOCHI - 2256906938

 Data Structure - 629401

void save() { node *temp;

if(start!=NULL) { FILE *fptr;

fptr = fopen("custom_circular_list.txt","w");

if(fptr == NULL) {

printf("Error in file!");

exit(0); }

temp=start;

while(temp->next!=NULL){

fprintf(fptr," %d -> ",temp->data);

temp = temp->next; }

fprintf(fptr," %d",temp->data);

printf("\n File is saved");

fclose(fptr); }

else { printf("\n The Queue is empty"); }}

int main() { do { printf("\n\t PERFORMING OPERATIONS USING LINKED LIST");

printf("\n\t ");

printf("\n\t 1. Create a list\n\t 2. Traverse the whole list\n\t 3. Delete first node\n\t 4. Delete last
node\n\t 5. Delete a node before specified data\n\t 6. Insert at first position\n\t 7. Insert at last
position\n\t 8. Insert a node before specified data\n\t 9. Insert a node at specified position\n\t 10.
Count\n\t 11. Copy (NOT DONE YET)\n\t 12. Merge two list (NOT DONE YET)\n\t 13. Reverse\n\t 14.
Search\n\t 15. Sort\n\t 16. Save\n\t 17. Exit");

printf("\n Enter the Choice:");

scanf("%d",&choice);

switch(choice) {

case 1: { create(); break; }

case 2: { traverse(); break; }

case 3: { delete_first(); break; }

ANIKET MOCHI - 2256906938

 Data Structure - 629401

case 4: { delete_last(); break; }

case 5: { delete_before(); break; }

case 6: { insert_first(); break; }

case 7: { insert_last(); break; }

case 8: { insert_before(); break; }

case 9: { insert_specified(); break; }

case 10: { count(); break; }

case 11: { break; }

case 12: { break; }

case 13: { reverse_list(); break; }

case 14: { search(); break; }

case 15: { sort_list(); break; }

case 16: { save(); break; }

case 17: { printf("\nExit point...\n"); break; }

default: { printf ("\n\t Please Enter a Valid Choice(1 to 17)"); } }}

while(choice!=17);

return 0; }

ANIKET MOCHI - 2256906938

 Data Structure - 629401

ANIKET MOCHI - 2256906938

 Data Structure - 629401

Program 17 : Create a user-defined structure with the following data members:

1. A Data 2. A link to the next node 3. A link to the previous node

Perform the following operations on doubly-linked Circular list using user defined functions:

1. Create a lisT 2. Traverse the whole list\ 3. Delete first node

4. Delete last node 5. Delete a node before specified data 6. Insert at first position

7. Insert at last position 8. Insert a node before specified data 9. Insert a node at specified position

10. Count 11. Copy 12. Merge two list

13. Reverse 14. Search 15. Sort

Create a file which stores all values of list.

#include<stdio.h>

#include<stdlib.h>

struct queue{

struct queue *prev;

int data;

struct queue *next;};

typedef struct queue node;

node *start=NULL,*rear=NULL;

int choice,i;

void create() { node *temp;

printf("\nCreating List\nEnter Data (Enter -1 to stop)...\n");

scanf("%d",&i);

while(i!=-1) {

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

temp->next=NULL;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

temp->prev=NULL;

temp->data=i;

if(start==NULL) {

start=temp;

rear=temp; }

else{ temp->prev=rear;

rear->next=temp;

temp->next=start;

start->prev=temp;

rear=temp; }

scanf("%d",&i); }

printf("\n-1 encountered\n");}

void traverse() { node *temp;

if(start==NULL) {

printf("\nCreate A LIST first...");

create(); }

else{ temp=start;

printf("\nThe list as below\n");

while(temp->next->data!=start->data){

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

temp=temp->next; }

printf(" %d",temp->data); }}

void delete_first() { node *temp;

if(start==NULL) { printf("\nThere is no list created\n"); }

else{ temp=start;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

start=start->next;

start->prev=rear;

rear->next=start;

printf("\nDeleted element is %d\n",temp->data);

free(temp); }}

void delete_last() {

node *temp;

if(start==NULL){ printf("\nThere is no list created\n"); }

else{ temp=rear;

rear=rear->prev;

rear->next=start;

start->prev=rear;

printf("\nDeleted element is %d\n",temp->data);

free(temp); }}

void delete_before() {

node *temp,*pre;

int flag=0,count=0;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

printf("\nEnter value before to be deleted\n");

scanf("%d",&i);

temp=start;

do{ count++;

if(temp->data==i) {

ANIKET MOCHI - 2256906938

 Data Structure - 629401

flag=1;

break; }

temp=temp->next;

}while (temp->data!=start->data);

if(flag==1){

if(count==1){ printf("Cannot delete before element of %d\n",i); }

else if(count==2){

temp=start;

start=start->next;

start->prev=rear;

rear->next=start;

free(temp); }

else{ temp=start;

while(temp!=NULL){

pre=temp;

temp=temp->next;

if(temp->next->data==i){

pre->next=temp->next;

temp->next->prev=pre;

free(temp);

break; } } } }

else{ printf("\nValue is not found\n"); }}

void insert_first(){

node *temp;

if(start==NULL){

ANIKET MOCHI - 2256906938

 Data Structure - 629401

printf("\nThere is no list created\n");

return; }

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

printf("Enter value to insert: ");

scanf("%d",&i);

temp->data=i;

temp->prev=rear;

temp->next=start;

start->prev=temp;

rear->next=temp;

start=temp;}

void insert_last(){

node *temp;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

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

printf("Enter value to insert: ");

scanf("%d",&i);

temp->data=i;

temp->next=start;

rear->next=temp;

temp->prev=rear;

start->prev=temp;

rear=temp;}

ANIKET MOCHI - 2256906938

 Data Structure - 629401

void insert_before(){

node *temp,*trav,*pre;

int val,flag=0,count=0;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

printf("Enter before value to insert: ");

scanf("%d",&val);

temp=start;

do{ count++;

if(temp->data==val) {

flag=1;

break; }

temp=temp->next;

}while (temp->data!=start->data);

if(flag==1){

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

printf("Enter value to insert: ");

scanf("%d",&i);

temp->data=i;

temp->next=NULL;

temp->prev=NULL;

if(count==1) {

temp->next=start;

start->prev=temp;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

rear->next=temp;

temp->prev=rear;

start=temp; }

else{ trav=start;

do{ pre=trav;

trav=trav->next;

if(trav->data==val){

pre->next=temp;

temp->prev=pre;

temp->next=trav;

trav->prev=temp;

break; }

}while(trav->data!=start->data); } }

else{ printf("\nValue is not found\n"); }}

void insert_specified(){

node *temp,*trav,*pre;

int val,flag=0,count=0;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

printf("Enter position to insert: ");

scanf("%d",&val);

val--;

if(val<1){ insert_first(); }

else{ trav=start;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

while(count!=val && trav->next->data!=start->data){

count++;

pre=trav;

trav=trav->next; }

if(count==val){

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

printf("Enter value to insert: ");

scanf("%d",&i);

temp->data=i;

temp->next=trav;

trav->prev=temp;

pre->next=temp;

temp->prev=pre; }

else{ insert_last(); } }}

void count(){

node *temp;

int count=0;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

temp=start;

do{ count++;

temp=temp->next;

}while(temp->data!=start->data);

printf("\nTotal Nodes: %d\n",count);}

ANIKET MOCHI - 2256906938

 Data Structure - 629401

void reverse_list(){

node *temp;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

temp=rear;

while(temp->prev->data!=rear->data){

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

temp=temp->prev; }

printf(" %d",temp->data);}

void search(){

node *temp;

int count=0,flag=0,val;

if(start==NULL){

printf("\nThere is no list created\n");

return; }

printf("Enter value to search: ");

scanf("%d",&val);

temp=start;

do{ count++;

if(val==temp->data){

flag=1;

break; }

temp=temp->next;

}while(temp->data!=start->data);

ANIKET MOCHI - 2256906938

 Data Structure - 629401

if(flag==0){

printf("Entered value is not found...\n"); }

else{ printf("%d is found at position: %d\n",val,count); }}

void sort_list(){

node *temp,*temp2;

int temp3;

if(start==NULL){ printf("\nThere is no list created\n"); return; }

temp=start;

do{ temp2=temp->next;

while(temp2!=NULL){

if(temp2->data<temp->data){

temp3=temp2->data;

temp2->data=temp->data;

temp->data=temp3; }

temp2=temp2->next; }

temp=temp->next;

}while(temp->data!=start->data);}

void save() {

node *temp;

if(start!=NULL) {

FILE *fptr;

fptr = fopen("custom_circular_doublylist.txt","w");

if(fptr == NULL) {

printf("Error in file!");

exit(0); }

ANIKET MOCHI - 2256906938

 Data Structure - 629401

temp=start;

while(temp->next->data!=start->data){

fprintf(fptr," %d -> ",temp->data);

temp = temp->next; }

fprintf(fptr," %d",temp->data);

printf("\n File is saved");

fclose(fptr); }

else { printf("\n The Queue is empty"); }}

int main(){

do {

printf("\n\t PERFORMING OPERATIONS USING LINKED LIST");

printf("\n\t ");

printf("\n\t 1. Create a list\n\t 2. Traverse the whole list\n\t 3. Delete first node\n\t 4. Delete last
node\n\t 5. Delete a node before specified data\n\t 6. Insert at first position\n\t 7. Insert at last
position\n\t 8. Insert a node before specified data\n\t 9. Insert a node at specified position\n\t 10.
Count\n\t 11. Copy (NOT DONE YET)\n\t 12. Merge two list (NOT DONE YET)\n\t 13. Reverse\n\t 14.
Search\n\t 15. Sort\n\t 16. Save\n\t 17. Exit");

printf("\n Enter the Choice:");

scanf("%d",&choice);

switch(choice) {

case 1: { create(); break; }

case 2: { traverse(); break; }

case 3: { delete_first(); break; }

case 4: { delete_last(); break; }

case 5: { delete_before(); break; }

case 6: { insert_first(); break; }

case 7: { insert_last(); break; }

ANIKET MOCHI - 2256906938

 Data Structure - 629401

case 8: { insert_before(); break; }

case 9: { insert_specified(); break; }

case 10: { count(); break; }

case 11: { break; }

case 12: { break; }

case 13: { reverse_list(); break; }

case 14: { search(); break; }

case 15: { sort_list(); break; }

case 16: { save(); break; }

case 17: { printf("\nExit point...\n"); break; }

default: { printf ("\n\t Please Enter a Valid Choice(1 to 17)"); } }}

while(choice!=17);

return 0;}

OUTPUT :

ANIKET MOCHI - 2256906938

 Data Structure - 629401

ANIKET MOCHI - 2256906938

 Data Structure - 629401

Program 18 : Write a program to represent an undirected graph using the adjacency matrix to
implement the graph and perform following operations, with menu driven options for following tasks:

1. Create graph 2. Insert an edge 3. Print Adjacency

Matrix

4. List all vertices that are adjacent to a specified vertex. 5. Print out vertices using depth
first search

6. Print out vertices using breadth first search 7. Exit program

#include <stdio.h>

#include <stdlib.h>

int dir_graph();

int undir_graph();

int read_graph(int adj_mat[50][50], int n);

void main() {

int option;

do {

printf("\n A Program to represent a Graph by using an ");

printf("Adjacency Matrix method \n ");

printf("\n 1. Directed Graph ");

printf("\n 2. Un-Directed Graph ");

printf("\n 3. Exit ");

printf("\n\n Select a proper option : ");

scanf("%d", &option);

switch (option) {

case 1:

dir_graph();

break;

ANIKET MOCHI - 2256906938

 Data Structure - 629401

case 2:

undir_graph();

break;

case 3:

exit(0);

} // switch

} while (1);

int dir_graph() {

int adj_mat[50][50];

int n;

int in_deg, out_deg, i, j;

printf("\n How Many Vertices ? : ");

scanf("%d", &n);

read_graph(adj_mat, n);

printf("\n Vertex \t In_Degree \t Out_Degree \t Total_Degree ");

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

in_deg = out_deg = 0;

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

if (adj_mat[j][i] == 1)

in_deg++; }

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

if (adj_mat[i][j] == 1)

out_deg++;

printf("\n\n %5d\t\t\t%d\t\t%d\t\t%d\n\n", i, in_deg, out_deg, in_deg + out_deg); }

return;}

ANIKET MOCHI - 2256906938

 Data Structure - 629401

int undir_graph() {

int adj_mat[50][50];

int deg, i, j, n;

printf("\n How Many Vertices ? : ");

scanf("%d", &n);

read_graph(adj_mat, n);

printf("\n Vertex \t Degree ");

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

deg = 0;

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

if (adj_mat[i][j] == 1)

deg++;

printf("\n\n %5d \t\t %d\n\n", i, deg); }

return;}

int read_graph(int adj_mat[50][50], int n) {

int i, j;

char reply;

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

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

if (i == j) {

adj_mat[i][j] = 0;

continue; }

printf("\n Vertices %d & %d are Adjacent ? (Y/N) :", i, j);

scanf("%c", &reply);

ANIKET MOCHI - 2256906938

 Data Structure - 629401

if (reply == 'y' || reply == 'Y')

adj_mat[i][j] = 1;

else

adj_mat[i][j] = 0; }}

return;}

OUTPUT:

ANIKET MOCHI - 2256906938

 Data Structure - 629401

Program 19 : Create a user-defined structure with the following data members:

1. A Data 2. A link to the Left child 3. A link to the Right child

Perform the following operations on Binary Search Tree using recursion:

1. Create 2. Traverse (Inorder, Preorder, Postorder) 3. Insert

4. Delete 5. Search 6. Create a file which stores all

values of traversal

#include<stdio.h>

#include<alloc.h>

#include<conio.h>

#include<stdio.h>

struct tree { int info;

struct tree *left;

struct tree *right; };

struct tree *insert(struct tree *,int);

void inorder(struct tree *);

void postorder(struct tree *);

void preorder(struct tree *);

struct tree *delet(struct tree *,int);

struct tree *search(struct tree *);

int main(void) {

struct tree *root;

int choice, item,item_no;

root = NULL;

do { do {

ANIKET MOCHI - 2256906938

 Data Structure - 629401

printf("\n********************MENU*********************\n");

printf("\n1. Insert in Binary Tree ");

printf("\n2. Delete from Binary Tree ");

printf("\n3. Inorder traversal of Binary tree");

printf("\n4. Postorder traversal of Binary tree");

printf("\n5. Preorder traversal of Binary tree");

printf("\n6. Search and replace ");

printf("\n7. Exit ");

printf("\n********************************************\n");

printf("\nEnter choice : ");

scanf(" %d",&choice);

if(choice<1 || choice>7)

printf("\n Invalid choice - try again"); }

while (choice<1 || choice>7);

switch(choice) {

case 1:

printf("\n Enter new element: ");

scanf("%d", &item);

root= insert(root,item);

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

printf("\n Inorder traversal of binary tree is : ");

inorder(root);

break;

case 2:

printf("\n Enter the element to be deleted : ");

ANIKET MOCHI - 2256906938

 Data Structure - 629401

scanf(" %d",&item_no);

root=delet(root,item_no);

inorder(root);

break;

case 3:

printf("\n Inorder traversal of binary tree is : ");

inorder(root);

break;

case 4:

printf("\n Postorder traversal of binary tree is : ");

postorder(root);

break;

case 5:

printf("\n Preorder traversal of binary tree is : ");

preorder(root);

break;

case 6:

printf("\n Search and replace operation in binary tree ");

root=search(root);

break;

default:

printf("\n End of program "); }

}while(choice !=7);

return(0);}

struct tree *insert(struct tree *root, int x) {

ANIKET MOCHI - 2256906938

 Data Structure - 629401

if(!root) {

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

root->info = x;

root->left = NULL;

root->right = NULL;

return(root); }

if(root->info > x)

root->left = insert(root->left,x); else {

if(root->info < x)

root->right = insert(root->right,x); }

return(root); }

void inorder(struct tree *root) {

if(root != NULL) {

inorder(root->left);

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

inorder(root->right); }

return;}

void postorder(struct tree *root) {

if(root != NULL) {

postorder(root->left);

postorder(root->right);

printf(" %d",root->info); }

return; }

void preorder(struct tree *root) {

if(root != NULL) {

ANIKET MOCHI - 2256906938

 Data Structure - 629401

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

preorder(root->left);

preorder(root->right); }

return; }

struct tree *delet(struct tree *ptr,int x) {

struct tree *p1,*p2;

if(!ptr) { printf("\n Node not found ");

return(ptr);

} else { if(ptr->info < x) {

ptr->right = delet(ptr->right,x);

} else if (ptr->info >x) {

ptr->left=delet(ptr->left,x);

return ptr;

} else

if(ptr->info == x)

if(ptr->left == ptr->right)

free(ptr);

return(NULL);

} else if(ptr->left==NULL) {

p1=ptr->right;

free(ptr);

return p1;

} else if(ptr->right==NULL) {

p1=ptr->left;

free(ptr);

ANIKET MOCHI - 2256906938

 Data Structure - 629401

return p1;

} else { p1=ptr->right;

p2=ptr->right;

while(p1->left != NULL)

p1=p1->left;

p1->left=ptr->left;

free(ptr);

return p2; } } } }

return(ptr);}

struct tree *search(struct tree *root) {

int no,i,ino;

struct tree *ptr;

ptr=root;

printf("\n Enter the element to be searched :");

scanf(" %d",&no);

fflush(stdin);

while(ptr) { if(no>ptr->info)

ptr=ptr->right; else if(no<ptr->info)

ptr=ptr->left; else

break; }

if(ptr) {

printf("\n Element %d which was searched is found and is = %d",no,ptr->info);

printf("\n Do you want replace it, press 1 for yes : ");

scanf(" %d",&i);

if(i==1) {

ANIKET MOCHI - 2256906938

 Data Structure - 629401

printf("\n Enter new element :");

scanf(" %d",&ino);

ptr->info=ino;

} else

printf("\n\t It's okay");

} else

printf("\n Element %d does not exist in the binary tree",no);

return(root);}

ANIKET MOCHI - 2256906938