Single ended Queue

#include<stdio.h>
void create(void);
void delete(void);
void display(void);
#define qmax 5
int q[qmax];
int r=-1;
int f=0;
char s[5];
int main()
{
//////////////////
while(1)
{
system("clear");
printf("\n\n\n-------------------------Single-Ended-Queue---------------------------------\n\n");

printf("\n\n                       1)    Enter Queue ");
printf("\n\n                       2)    Display");
printf("\n\n                       3)    Delete");
printf("\n\n                       4)    Exit");

printf("\n\n\n-----------------------------------------------------------------\n\n");
printf("\n\nEnter the choice  :");


int x;
scanf("%d",&x);
switch(x)
{
    case 1:
    {
    create();
    break;
    }
    case 2:
    {
    display();
    break;
    }
    case 3:
    {
    delete();
    break;
    }
    case 4:
    {
    return;
    }
    default:
    {printf("\n\nEnter valid Choice  :\n\n");
         printf("\n\n\n\n\n\nPress any Key  :\n");
         gets(s);
         gets(s);
    break;}
}
}
}

//////////////////////////////////////////////////////////////////
void create(void)
{
int data;
if(r==(qmax-1))
{
 printf("\n\nQueue is over flow\n");
 printf("\n\n\n\n\n\nPress any Key  :\n");
 gets(s);
 gets(s);
 return;
}
r=r+1;
printf("\n\nEnter the Queue data   :");
scanf("%d",&data);
q[r]=data;
}

/////////////////////////////////////////////////////////////
void delete(void)
{
if(f>r)
 {
  printf("\n\nQueue is under flow");
  printf("\n\n\n\n\n\n\nPress any Key  :\n");
  gets(s);
  gets(s);
  return;
 }
f=f+1;
if(f>r)
{
f=0;
r=-1;
}
}


void display(void)
{
int i;
if(f==0&&r==-1)
{
 printf("--->-Queue is now free---->-");
 printf("\n\n\n\n\n\n\nPress any Key  :\n");
 gets(s);
 gets(s);
 return;
}


printf("\n\n\n\nrear end------>");
for(i=f;i<=r;i++)
  {
  printf("%d-----",q[i]);  
  }
printf("front end--->\n\n\n\n\n\n\nPress any Key  :\n");
gets(s);
gets(s);
}

/////////////////////////////////////////////////////////////////

Application--Polinomial addition

#include<stdio.h>
#include<stdlib.h>
////structure      //////////
struct Poly
    {
    struct Poly *next;
    int exp;
    int coeff;
    };

/////////////Functions declaration ///////////
struct Poly* CreatePoly();
struct Poly* AddPoly(struct Poly* ,struct Poly*);
void DisplayPoly(struct Poly*);
/////Main /////////////
int main()
{
while(1)
{
system("clear");
    struct Poly *P1,*P2,*P3;
    int x;
    char s[5];
    printf("\n\n\n-------------------Polynomial  Addition ----------------\n\n");   
    printf("        1)   Enter First Polynomial Details\n");   
    printf("        2)   Enter Second Polynomial Details\n");   
    printf("        3)   Exit  \n ");
    printf("--------------------------------------------------------\n");   
    printf("Enter the chioce  :");   
    scanf("%d",&x);
switch(x)
{   
case 1:
    {
    P1 = CreatePoly();
    break;
    }
case 2:   
    {
    P2 = CreatePoly();
    P3 = AddPoly(P1,P2);
    system("clear");
        printf("\n\n\n\n\nFirst Polynomial        :  ");
    DisplayPoly(P1);
    printf("\n\nSecond Polynomial       :  ");
    DisplayPoly(P2);
    printf("\n--------------------------------------------------");
    printf("\n\nResult                  :  ");
    DisplayPoly(P3);
    printf("\n\n\n\n\n\n\nPress Any Key to return :");
    gets(s);
    gets(s);
    break;
    }
case 3:   
    {
    return 0;
    }
default:
    {
    printf("Enter valid choice\n");
    printf("\n\n\n\n\n\n\nPress Any Key to return :");
    gets(s);
    gets(s);
    }

}
}
}
////////Function Definition /////////////////
void DisplayPoly(struct Poly* P)
{   
    while(P != NULL)
    {
        printf("+(%d)x^%d ",P->coeff,P->exp);
        P = P->next;
    }
}

struct Poly* CreatePoly()
{
    int count;
    struct Poly* start=NULL,*new=NULL;
    struct Poly* temp=NULL;
    printf("\nEnter the number of Polynomial terms: ");
    scanf("%d",&count);
    while(count--)
          {
        new = malloc( sizeof(struct Poly) );
        printf("\nTerm %d:\nCoefficient  : ",count+1);
        scanf("%d",&new->coeff);
        printf("Exponent      ");
        scanf("%d",&new->exp);

        if(start == NULL || start->exp < new->exp)
         {
            new->next = start;
            start = new;
         }
        else
         {
          temp = start;
            while(temp->next != NULL && temp->next->exp > new->exp)
                temp = temp->next;   
       
            new->next = temp->next;
            temp->next = new;
        }
          }
    return start;
}
   
struct Poly* AddPoly( struct Poly* P1, struct Poly* P2)
{
    struct Poly* P3_start = NULL;
    struct Poly* P3,*temp;
   
    while(P1 != NULL && P2 != NULL )
    {
          temp = malloc( sizeof(struct Poly) );
      temp->next=NULL;   
        if(P3_start == NULL)
        {
            P3_start = temp;
            P3 = temp;
        }
        else
        {
            P3->next = temp;
            P3 = P3->next;
        }
       
        if( P1->exp > P2->exp)
        {
            temp->exp = P1->exp;
            temp->coeff = P1->coeff;
            P1 = P1->next;
        }
        else if(P1->exp < P2->exp)
        {
            temp->exp = P2->exp;
            temp->coeff = P2->coeff;
            P2 = P2->next;
        }
        else if(P1->exp == P2->exp)
        {
            temp->exp = P1->exp;
            temp->coeff = P1->coeff + P2->coeff;
            P1 = P1->next;
            P2 = P2->next;
        }
   
    }
       
    while(P1 != NULL) {
               
        temp = (struct Poly*)malloc( sizeof(struct Poly) );
        temp->coeff = P1->coeff;
        temp->exp = P1->exp;
        P1 = P1->next;
       
        P3->next = temp;
        P3 = P3->next;
    }
    while(P2 != NULL) {
           
        temp = (struct Poly*)malloc( sizeof(struct Poly) );
        temp->coeff = P2->coeff;
        temp->exp = P2->exp;
        P2 = P2->next;
       
        P3->next = temp;
        P3 = P3->next;
    }
   
    return P3_start;

}

Circular Link list

   
    ///////   Created   By  ///////////////////////////////
    ///                                                        ///
    ///                                                        ///
    ///     MUHAMMED ISMAIL  PP     ///
    ///                                                       ///
    ///                                                       ///
    /////////////////////////////////////////////////////////////



#include<stdio.h>
#include<stdlib.h>
void create(void);
void sorted_create(void);
void display(void);
void insert_first(void);
void insert_btwn(int x);
void delete(int data);
void reverse(void);
char s[5];    
       struct clist
        {
        int data;
    struct clist *next;
    }*start=NULL;
///////////////////Main////////////////////////////////////////
int main()
{   
while(1)
{
system("clear");
printf("\n");
printf("                ---------------------Circular Link List Data Structure------------- \n\n");
printf("                                 1--Create \n\n");
printf("                                     2--view \n\n");
printf("                             3--insert\n\n");
printf("                             4--Delete\n\n");
printf("                                 5--Reverse\n\n");
printf("                                6--Exit\n\n");
printf("                ------------------------------------------------------------------- \n\n");
int x;
int i;
printf("Enter choice   :");
    scanf("%d",&x);
switch(x)
    {
     case 1:
     {
system("clear");
    printf("\nSelect your choice :\n");
    printf("\n--------------------------------------------\n");
    printf("\n        1)---Create Normal Structure :\n");
    printf("\n        2)---Create Sorted Structure :\n");
    printf("\n--------------------------------------------\n");
    scanf("%d",&x);
    switch (x)
    {
        case 1:
         {
        printf("\n\n\nEnter the number of elements  :");
         scanf("%d",&x);
           for(i=0;i<x;i++)
           {
            printf("\nEnter the  data %d = ",i+1);
                 create();
           }
   
        printf("\nYour Data Structure  Successfully Created");
            printf("\n-----------------------------------\n");
               sleep(1);
        break;
          }
        case 2:
        {
         printf("\n\n\nEnter the number of elements  :");
                 scanf("%d",&x);
                   for(i=0;i<x;i++)
                   {
                    printf("\nEnter the  data %d = ",i+1);
                    sorted_create();
                   }

                printf("\nYour Data Structure  Successfully Created");
                printf("\n-----------------------------------\n");
                sleep(1);
                break;
        }
      }
       break;
     }   
      case 2:
    {
    gets(s);
    display();
    break;
    }
      case 3:
    {
    printf("\nEnter the position :");
    scanf("%d",&x);
      if(x==1)
          {
     insert_first();
      }
      else
      {
     insert_btwn(x);
      }
    break;
        }
      case 4:
    {
     printf("\nEnter the data for delete  : ");
     scanf("%d",&x);
      gets(s);
     delete(x);
     break;
    }   
      case 5:
    {
     reverse();
     printf("\nYour Data Structure  Successfully Reversed\n");
         printf("-------------------------------------------\n");
     sleep(2);
    break;
    }
      case 6:       
    {
    return;
    break;
    }
      default:
    {
    gets(s);
    printf("\n\nEnter  valid Choice : Press Any Key to Return :  ");
    gets(s);
    break;
    }

}

}
return ;
}
///////////////////////Create//////////////////////////////////

void create(void)
{
   struct clist *temp,*tr;
    temp=malloc(sizeof(struct clist));
    scanf("%d",&temp->data);
    temp->next=NULL;
    if(start==NULL)
    {
    start=temp;
    temp->next=temp;
    }   
    else
    {
    tr=start;
        while(tr->next !=start)
            {
        tr=tr->next;
        }
    
    tr->next=temp;
    temp->next=start;
    }
}

/////////////////////////////////////////////////////////////////////
void display(void)
{
    char s[5];
int ct=0;
       printf("\n\n\n\n\n\n\n             START\n");   
       printf("              |\n");
       printf("              |\n");
       printf("              |\n");
       printf("              |\n");
       printf("              ");
        struct clist *tr;
    tr=start;
    if(start==NULL)
    {
        printf("-->  No Data");

    }
       else
       {
    while (tr->next!=start)
    {
        printf("-->  %d ",tr->data);
    tr=tr->next;
    ct=ct+7;
    }
        printf("-->  %d",tr->data);       //to print  last element
       ct=ct+7;
      }
///////////
if(start!=NULL)
{
printf("\n");
printf("%*c",15,'|');
printf("%*c\n",ct,'|');
printf("%*c",15,'|');
printf("%*c\n",ct,'|');
printf("%*c",15,'|');
printf("%*c\n",ct,'|');
printf("%*c",15,'<');
int i;
for(i=0;i<ct;i++)
{printf("-");}
}
//////////////////

 printf("\n\n\n\n\n\n\nPRESS ENTER KEY");
 gets(s);
}



////////////////////////////////////////////////////////////////////////
void insert_first(void)
{
    struct clist *temp,*tr;
    temp=malloc(sizeof(struct clist));
        printf("\nEnter the data : ");
    scanf("%d",&temp->data);
    tr=start;
    temp->next=start;
        while(tr->next!=start)       
        {
        tr=tr->next;
        }
    tr->next=temp;
    start=temp;


    printf("\nYour Data  Successfully  Saved in First Position");
        printf("\n-----------------------------------\n");
        sleep(1);
}
///////////////////////////////////////////////////////////////////////
void insert_btwn(int x)
{
int i;   
    struct clist *tr,*temp;
    tr=start;
    for(i=0;i<x-2;i++)
    {
     tr=tr->next;
    }
    temp=malloc(sizeof(struct clist));
    printf("\nEnter the data : ");
    scanf("%d",&temp->data);
    temp->next=tr->next;
    tr->next=temp;
        printf("\nYour Data  Successfully Saved in  Position %d ",x);
        printf("\n-----------------------------------\n");
        sleep(1);
}
////////////////////////////////////////////////////////////////////////

void delete(int data)
{
 struct clist *temp,*tr;
        ////////// if only one data /////////////
    if(start->next==start&&start->data==data)
    {
    temp=start;
    start=NULL;
    free(temp);
        printf("\nYour Data1 %d is  Successfully Deleted ",data);
        printf("\n-----------------------------------\n");
        sleep(2);
    return;
          }
    tr=start->next;
    ////////// data in starting positoin ///////
    if(tr->data==data)
            {
         temp=tr;
         start->next=temp->next;
         free(temp);
            printf("\nYour Data2 %d is  Successfully Deleted ",data);
                printf("\n-----------------------------------\n");
                 sleep(2);
         return;
        }

        ////////// if middle ////////////////////////////////
    while(tr->next!=start)
         {
        if(tr->next->data==data)
         {
         temp=tr->next;
         tr->next=temp->next;
         free(temp);
         printf("\nYour Data3 %d is Successfully Deleted",data );
                printf("\n----------------------------------\n");
                sleep(2);
        return ;
         }
        tr=tr->next;
        }
        ///////// Last //////////////////////////////////////      
     if(tr->next->data==data)
        {
        temp=tr->next;
        tr->next=temp->next;
        free(temp);
        start=tr;
        printf("\nYour Data4 %d is Successfully Deleted",data);
        printf("\n----------------------------------\n");
        sleep(2);
        }
    else
        {
        printf("\nThis data not exist");
        printf("\n\n\n\n\n\n\n\n\npress any key ");
        gets(s);
        }       
   
}
//////////////Reverse /////////////////////////////////////////////////

void reverse(void)
{
struct clist *temp,*tr0,*tr;
temp=malloc(sizeof(struct clist));
tr=tr0=start;
temp=start->next;
start->next=NULL;
    while(temp!=start)
    {
    tr=temp;
    temp=temp->next;
    tr->next=tr0;
    tr0=tr;
    }
  start->next=tr; 
  start=tr;
          
}
////////////////////////////////////////////////////////////////////////

void sorted_create(void)
{
struct clist *temp,*tr;
temp=malloc(sizeof(struct clist));
scanf("%d",&temp->data);
temp->next=NULL;
if(start==NULL||start->data>temp->data)
 {
   if(start==NULL)
   {
    start=temp;
    start->next=start;
   }
    start->next=temp;
    temp->next=start;
    start=temp;
    return;
 }
else
{
  tr=start;


while(tr->next!=start&&tr->next->data<temp->data)
    {
    tr=tr->next;
    }
temp->next=tr->next;
tr->next=temp;
}
}

Double Link

   
    ///////   Created   By  //////////////////////////////
    ///                                                         ///
    ///                                                        ///
    ///     MUHAMMED ISMAIL  PP     ///
    ///                                                        ///
    ///                                                         ///
    //////////////////////////////////////////////////////////////



#include<stdio.h>
#include<stdlib.h>
void create(void);
void sorted_create(void);
void display(void);
void insert_first(void);
void insert_btwn(int x);
void delete(int data);
void reverse(void);
char s[5];    
       struct dlist
        {
        int data;
    struct dlist *next;
    struct dlist *previous;
    }*start=NULL;
///////////////////Main////////////////////////////////////////
int main()
{   
while(1)
{
system("clear");
printf("\n");
printf("                ---------------------Double List Data Structure-------------------- \n\n");
printf("                                 1--Create \n\n");
printf("                                     2--view \n\n");
printf("                             3--insert\n\n");
printf("                             4--Delete\n\n");
printf("                                 5--Reverse\n\n");
printf("                                6--Exit\n\n");
printf("                ------------------------------------------------------------------- \n\n");
int x;
int i;
printf("Enter choice   :");
    scanf("%d",&x);
switch(x)
    {
     case 1:
     {
system("clear");
    printf("\nSelect your choice :\n");
    printf("\n--------------------------------------------\n");
    printf("\n        1)---Create Normal Structure :\n");
    printf("\n        2)---Create Sorted Structure :\n");
    printf("\n--------------------------------------------\n");
    scanf("%d",&x);
    switch (x)
    {
        case 1:
         {
        printf("\n\n\nEnter the number of elements  :");
         scanf("%d",&x);
           for(i=0;i<x;i++)
           {
            printf("\nEnter the  data %d = ",i+1);
                    create();
           }
   
        printf("\nYour Data Structure  Successfully Created");
            printf("\n-----------------------------------\n");
               sleep(2);
        break;
          }
        case 2:
        {
         printf("\n\n\nEnter the number of elements  :");
                 scanf("%d",&x);
                   for(i=0;i<x;i++)
                   {
                    printf("\nEnter the  data %d = ",i+1);
                    sorted_create();
                   }

                printf("\nYour Data Structure  Successfully Created");
                printf("\n-----------------------------------\n");
                sleep(2);
                break;
        }
      }
       break;
     }   
      case 2:
    {
    gets(s);
    display();
    break;
    }
      case 3:
    {
    printf("\nEnter the position :");
    scanf("%d",&x);
      if(x==1)
            { insert_first();}
      else
        { insert_btwn(x); }
    break;
        }
      case 4:
    {
     printf("\nEnter the data for delete  : ");
     scanf("%d",&x);
      gets(s);
     delete(x);
     break;
    }   
      case 5:
    {
    reverse();
    break;
    }
      case 6:       
    {
    return;
    break;
    }
      default:
    {
    gets(s);
    printf("\n\nEnter  valid Choice : Press Any Key to Return :  ");
    gets(s);
    break;
    }

}

}
return ;
}
///////////////////////Create//////////////////////////////////
void create(void)
{
   struct dlist *temp,*tr;
    temp=malloc(sizeof(struct dlist));
    scanf("%d",&temp->data);
    temp->next=NULL;
    temp->previous=NULL;
   
    if(start==NULL)
    {
    start=temp;
    }   
    else
    {
    tr=start;
        while(tr->next !=NULL)
            {
        tr=tr->next;
        }
    
    tr->next=temp;
    temp->previous=tr;
    }

}

/////////////////////////////////////////////////////////////////////
void display(void)
{
    char s[5];
       printf("\n\n\n\n\n\n\n             START\n");   
       printf("              |\n");
       printf("              |\n");
       printf("              |\n");
       printf("              |\n");
       printf("              ");
        struct dlist *tr;
    tr=start;
   
    if(start==NULL)
    {
        printf("-->  No Data");
    }
        while (tr!=NULL)
    {
        printf("-->  %d",tr->data);
    tr=tr->next;
    }
       printf("\n\n\n\n\n\n\nPRESS ENTER KEY");
       gets(s);
}
////////////////////////////////////////////////////////////////////////
void insert_first(void)
{
    struct dlist *temp;
    temp=malloc(sizeof(struct dlist));
        printf("\nEnter the data : ");
    scanf("%d",&temp->data);
    temp->next=start;
    start->previous=temp;
    start=temp;


        printf("\nYour Data  Successfully  Saved in First Position");
        printf("\n-----------------------------------\n");
        sleep(2);



}
///////////////////////////////////////////////////////////////////////
void insert_btwn(int x)
{
int i;   
    struct dlist *tr,*temp;
    tr=start;
    for(i=0;i<x-2;i++)
    {
     tr=tr->next;
    }
    temp=malloc(sizeof(struct dlist));
    printf("\nEnter the data : ");
    scanf("%d",&temp->data);
    temp->next=tr->next;
    tr->next=temp;
    temp->previous=tr;
    if(temp->next!=0)
    {temp->next->previous=temp;}


       
        printf("\nYour Data  Successfully Saved in  Position %d ",x);
        printf("\n-----------------------------------\n");
        sleep(2);


}
////////////////////////////////////////////////////////////////////////
void delete(int data)
{
 struct dlist *temp,*tr;
        ////////// if data in  Starting position /////////////
    if(start->data==data)
    {
          if(start->next!=NULL)
            {
         temp=start;
         start=start->next;
         start->previous=NULL;
           free(temp);
          }
    else
        {
                start=NULL;
                }
    printf("\nYour Data %d is  Successfully Deleted ",data);
        printf("\n-----------------------------------\n");
        sleep(2);
     }

        ////////// if middle ////////////////////////////////

    else
    {
    tr=start;
    while(tr->next->next!=NULL)
         {
        if(tr->next->data==data)
         {
         temp=tr->next;
         tr->next=temp->next;
         temp->next->previous=tr;
         free(temp);
         printf("\nYour Data %d is Successfully Deleted",data );
                printf("\n----------------------------------\n");
                sleep(2);
        return ;
         }
        tr=tr->next;
        }
        ///////// Last //////////////////////////////////////      
     if(tr->next->data==data)
        {
        temp=tr->next;
        tr->next=NULL;
        free(temp);
        printf("\nYour Data %d is Successfully Deleted",data);
        printf("\n----------------------------------\n");
        sleep(2);
        }
    else
        {
        printf("\nThis data not exist");
        printf("\n\n\n\n\n\n\n\n\npress any key ");
        gets(s);
        }       
    }
}
//////////////Reverse /////////////////////////////////////////////////
void reverse(void)
{
struct dlist *temp,*tr0,*tr;
temp=malloc(sizeof(struct dlist));
tr=tr0=start;
temp=start->next;
start->next=NULL;
    while(temp!=NULL)
    {
    tr=temp;
    tr0->previous=tr;
    temp=temp->next;
    tr->next=tr0;
    tr->previous=temp;
    tr0=tr;
    }
start=tr;
}
////////////////////////////////////////////////////////////////////////

void sorted_create(void)
{
struct dlist *temp,*tr;
temp=malloc(sizeof(struct dlist));
scanf("%d",&temp->data);
temp->next=NULL;
temp->previous=NULL;
if(start==NULL||start->data>temp->data)
 {
  if(start!=NULL)
    {start->previous=temp;}
   temp->next=start;
   start=temp;
return;
 }
else
{
  tr=start;


while(tr->next!=NULL&&tr->next->data<temp->data)
    {
    tr=tr->next;
    }

temp->previous=tr;
temp->next=tr->next;
tr->next=temp;

 if(temp->next!=NULL)
  {
  temp->next->previous=temp;
  }
}

}

Single Link

   
    ///////   Created   By  ///////////////////////////////
    ///                                                         ///
    ///                                                         ///
    ///     MUHAMMED ISMAIL  PP     ///
    ///                                                        ///
    ///                                                       ///
    /////////////////////////////////////////////////////////////



#include<stdio.h>
#include<stdlib.h>
void create(void);
void sorted_create(void);
void display(void);
void insert_first(void);
void insert_btwn(int x);
void delete(int data);
void reverse(void);
char s[5];    
       struct list
        {
        int data;
    struct list *next;
    }*start=NULL;
///////////////////Main////////////////////////////////////////
int main()
{   
while(1)
{
system("clear");
printf("\n");
printf("                     ---------------Single List Data Structure-------------------- \n\n");
printf("                             1--Create \n\n");
printf("                                 2--view \n\n");
printf("                         3--insert\n\n");
printf("                         4--Delete\n\n");
printf("                             5--Reverse\n\n");
printf("                             6--Exit\n\n");
printf("                 ------------------------------------------------------------- \n\n");
int x;
int i;
printf("Enter choice   :");
    scanf("%d",&x);
switch(x)
    {
     case 1:
     {
    system("clear");
    printf("\nSelect your choice :\n");
    printf("\n--------------------------------------------\n");
    printf("\n        1)---Create Normal Structure :\n");
    printf("\n        2)---Create Sorted Structure :\n");
    printf("\n--------------------------------------------\n");
    scanf("%d",&x);
    switch (x)
    {
        case 1:
         {
        printf("\n\n\nEnter the number of elements  :");
         scanf("%d",&x);
           for(i=0;i<x;i++)
           {
            printf("\nEnter the  data %d = ",i+1);
                    create();
           }
   
        printf("\nYour Data Structure  Successfully Created");
            printf("\n-----------------------------------\n");
               sleep(2);
        break;
          }
        case 2:
        {
         printf("\n\n\nEnter the number of elements  :");
                 scanf("%d",&x);
                   for(i=0;i<x;i++)
                   {
                    printf("\nEnter the  data %d = ",i+1);
                    sorted_create();
                   }

                printf("\nYour Data Structure  Successfully Created");
                printf("\n-----------------------------------\n");
                sleep(2);
                break;
        }
     }
    break;
    }   
      case 2:
    {
    gets(s);
    display();
    break;
    }
      case 3:
    {
    printf("\nEnter the position :");
    scanf("%d",&x);
      if(x==1)
            { insert_first();}
      else
        { insert_btwn(x); }
    break;
        }
      case 4:
    {
     printf("\nEnter the data for delete  : ");
     scanf("%d",&x);
      gets(s);
     delete(x);
     break;
    }   
      case 5:
    {
    reverse();
    break;
    }
      case 6:       
    {
    return;
    break;
    }
      default:
    {
    gets(s);
    printf("\n\nEnter  valid Choice : Press Any Key to Return :  ");
    gets(s);
    break;
    }

}

}
return ;
}
///////////////////////Create//////////////////////////////////
void create(void)
{
   struct list *temp,*tr;
    temp=malloc(sizeof(struct list));
    scanf("%d",&temp->data);
    temp->next=NULL;
   
   
    if(start==NULL)
    {
    start=temp;
    }   
    else
    {
    tr=start;
        while(tr->next !=NULL)
            {
        tr=tr->next;
        }
    
    tr->next=temp;
    }
}
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
void display(void)
{
    char s[5];
       printf("\n\n\n\n\n\n\n\n\n\n\n\n             START\n");   
       printf("              |\n");
       printf("              |\n");
       printf("              |\n");
       printf("              |\n");
       printf("              ");
        struct list *tr;
    tr=start;
   
    if(start==NULL)
        {
        printf("-->  No Data");
        }


    while (tr!=NULL)
    {
       printf("-->  %d",tr->data);
    tr=tr->next;
    }
       printf("\n\n\n\nPRESS ENTER KEY");
       gets(s);
}
////////////////////////////////////////////////////////////////////////
void insert_first(void)
{
    struct list *temp;
    temp=malloc(sizeof(struct list));
        printf("\nEnter the data : ");
    scanf("%d",&temp->data);
    temp->next=start;
    start=temp;

        printf("\nYour Data  Successfully  Saved in First Position");
        printf("\n-----------------------------------\n");
        sleep(2);





}
///////////////////////////////////////////////////////////////////////
void insert_btwn(int x)
{
int i;   
    struct list *tr,*temp;
    tr=start;
    for(i=0;i<x-2;i++)
    {
     tr=tr->next;
    }
    temp=malloc(sizeof(struct list));
    printf("\nEnter the data : ");
    scanf("%d",&temp->data);
    temp->next=tr->next;
    tr->next=temp;

        printf("\nYour Data  Successfully Saved in  Position %d ",x);
        printf("\n-----------------------------------\n");
        sleep(2);

}
////////////////////////////////////////////////////////////////////////
void delete(int data)
{
 struct list *temp,*tr;
        ////////// if data in  Starting position /////////////
    if(start->data==data)
    {
     temp=start;
     start=start->next;
     free(temp);
      
        printf("\nYour Data %d is  Successfully Deleted ",data);
        printf("\n-----------------------------------\n");
        sleep(2);
   


       }

        ////////// if middle ////////////////////////////////

    else
    {
    tr=start;
    while(tr->next->next!=NULL)
         {
        if(tr->next->data==data)
         {
         temp=tr->next;
         tr->next=temp->next;
         free(temp);
       
              printf("\nYour Data %d is  Successfully Deleted ",data);
                printf("\n-----------------------------------\n");
                   sleep(2);


        return ;
         }
        tr=tr->next;
       
        }
        ///////// Last //////////////////////////////////////      
     if(tr->next->data==data)
        {
        temp=tr->next;
        tr->next=NULL;
        free(temp);
       

             printf("\nYour Data %d is  Successfully Deleted ",data);
               printf("\n-----------------------------------\n");
             sleep(2);


         }
    else
        {
        printf("\nThis data not exist");
        printf("\n\n\n\n\n\n\n\n\npress any key ");
        gets(s);
        }       
    }
}
///////////////////Reverse /////////////////////////////////////////////////
void reverse(void)
{
struct list *temp,*tr,*tr0;

tr=tr0=start;
temp=start->next;
start->next=NULL;

while(temp!=NULL)
{
tr=temp;
temp=temp->next;
tr->next=tr0;
tr0=tr;
}
start=tr;



        printf("\nYour Data  is  Reversed in Position  ");
        printf("\n-----------------------------------\n");
        sleep(2);


}

/////////////////////////////////////////////////////////////////////////

void sorted_create(void)
{
struct list *temp,*tr;
temp=malloc(sizeof(struct list));
scanf("%d",&temp->data);
temp->next=NULL;
if(start==NULL||start->data>temp->data)
 {
 temp->next=start;
 start=temp;
 return;
 }
else
 {
 tr=start;
 }

while(tr->next!=NULL&&tr->next->data<temp->data)
    {
    tr=tr->next;
    }

temp->next=tr->next;
tr->next=temp;
}