c assignment 6

↓↑ Program to implement binary Search. 

#include<stdio.h>
int main()
{
 int low,high,mid,i,a[15],key,n;
 printf("Enter No  in array in sorted order:");
 scanf("%d",&n);
 for(i=0;i<n;i++)
  scanf("%d",&a[i]);

 low=0;
 high=n-1;
 printf("\nenter key to be searched:");
 scanf("%d",&key);
 for(i=0;i<n;i++)
 { 
  mid=(low+high)/2;
  if(a[mid]==key)
  {
   printf("element fount at %d position\n",mid+1); 
   break;
  }
   
  if(a[mid]<key)
   low=mid+1;
  if(a[mid]>key)
   high=mid-1;
  
 }
return 0;
}


↓↑ Program to implement bubble sort. 

#include<stdio.h>
#define MAX 15
int main()
{
 int a[MAX],i,temp,j,n;
 printf("enter the no of element:");
 scanf("%d",&n);
 for(i=0;i<n;i++)
  scanf("%d",&a[i]);
 for(i=0;i<n;i++)
 {
  for(j=0;j<n-1-i;j++)
  {
   if(a[j]>a[j+1])
   {
    temp=a[j+1];
    a[j+1]=a[j];
    a[j]=temp;
   }
  }
 }
printf("sorted array is:");
for(i=0;i<n;i++)
printf("%d\t",a[i]);
printf("\n");
return 0;
}


↓↑ Program to implement circular queue.

#include<stdio.h>
#define MAXSIZE 5
int cq[10];
int front=-1,rear=0;
int choice;
char ch;
void main()
{

do
{

    printf("1.Insert-------\n");
    printf("2. Delete------\n");
    printf("3. Display-----\n");
    printf("4.exit---------\n");
    printf("Enter your choice:");
    scanf("%d",&choice);
    switch(choice)
    {
        case 1 : cqinsert();
        break;
        case 2 : cqdelete();
        break;
        case 3 : cqdisplay();
        break;
        case 4: return;
    }
        fflush(stdin);
}while(choice!=4);

}
cqinsert()
{
    int num;
    if(front==(rear+1)%MAXSIZE)
    {
        printf("Queue is full\n");
        return;
    }
    else
    {
        printf("Enter the element to be inserted\n");
        scanf("%d",&num);
        if(front==-1)
            front=rear=0;
        else
            rear=(rear+1) % MAXSIZE;
        cq[rear]= num;
    }
    return;
}

int cqdelete()
{
    int num;
    if(front==-1)
    {
        printf("Queue is Empty\n");
        return;
    }
    else
    {
        num=cq[front];
        printf("Deleted element is =%d\n",cq[front]);
        if(front==rear)
            front=rear=-1;
        else
            front=(front+1)%MAXSIZE;
    }
     return(num);
}

cqdisplay()
{
    int i;
    if(front==-1)
    {
        printf("Queue is empty\n");
        return;
    }
    else
    {
        printf("\nThe status of the queue\n");
        for(i=front;i<=rear;i++)
        {
            printf("%d\n",cq[i]);
        }
    }
    if(front>rear)
    {
        for(i=front;i<MAXSIZE;i++)
        {
            printf("%d\n",cq[i]);
        }
        for(i=0;i<=rear;i++)
        {
            printf("%d\n",cq[i]);
        }
    }
printf("\n");
}


↓↑ Program to implement infix to postfix expression.

#include<stdio.h>
#include<string.h>
char stack[50];
int top=-1;
void in_to_post(char infix[]);
void push (char);
char pop();
int main()
{
    char infx[25];
    printf("Enter the infix expression");
    gets(infx);
    in_to_post(infx);
return 0;
}

void push (char symb)
{
    if (top>=49)
    {
     printf("stack overflow");
        return;
    }
    else
    {
     top=top+1;
     stack[top]=symb;
    }
}

char pop()
{
    char item;
    if(top==-1)
    {
     printf("stack empty");
 return(0);
    }
    else
    {
     item=stack[top];
     top--;
    }
return(item);
}

int preced(char ch)
{
    if(ch==47)
    {
     return(5);
    }
    else
    if(ch==42)
    {
     return(4);
    }
    else if(ch==43)
    {
     return(3);
    }
    else
return(2);
}
void in_to_post(char infix[])
{
    int length;
    static int index=0,pos=0;
    char symbol,temp;
    char postfix[40];
    length=strlen(infix);
    push('#');
    while(index<length)
    {
     symbol=infix[index];
     switch(symbol)
     {
      case'(':push(symbol);
       break;
      case')' :temp=pop();
      while(temp!='(')
      {
       postfix[pos]=temp;
       pos++;
       temp=pop();
      }
      break;
      case '+' :
      case '-' :
      case '*' :
      case '/' :
      case '^' :
      while (preced(stack[top])>=preced(symbol))
      {
       temp=pop();
       postfix[pos]=temp;
       pos++;
      }
      push(symbol);
      break;
      default : postfix[pos++]=symbol;
       break;
     }
    index++;
    }
    while(top>0)
    {
        temp=pop();
 postfix[pos++]=temp;
    }
    postfix[pos++]='\0';
    puts(postfix);
    return;
}


↓↑ Program to implement insertion sort. 

#include<stdio.h>
int main()
{
 int a[15],i,k,key,n;
 printf("enter no of element in  array n=:");
 scanf("%d",&n);
 printf("enter array element:");
 
 for(i=0;i<n;i++)
 { 
   scanf("%d",&a[i]);
 }
 
 for(k=1;k<n;k++)
 {
  key=a[k];
  for(i=k-1;key<a[i]&&i>=0;i--)
  {
   a[i+1]=a[i];
  }
 a[i+1]=key; 
 }
 printf("sorted array is::");
 for(i=0;i<n;i++)
 printf("%d\t",a[i]);

printf("\n");
return 0;
}


↓↑ Program to implement linear search. 

#include<stdio.h>
#define MAX 15
int main()
{
 int a[MAX],i,n,item,flag=0,pos;
 printf("enter how many element you want to enter:");
 scanf("%d",&n);
 for(i=0;i<n;i++)
 {
 scanf("%d",&a[i]);
 } 
 printf("\nenter item to be searched:");
 scanf("%d",&item);
 for(i=0;i<n;i++)
 {
  if(item==a[i])
  {
    flag=1;
   pos=i;
   break;
  }
 }
 if(flag==1) 
 printf("item found at %d position\n",pos);
 else
 printf("item not found\n");
return 0;
}



↓↑ Program to implement merge sort. 

#include<stdio.h>
#define MAX 50

void mergeSort(int arr[],int low,int mid,int high);
void partition(int arr[],int low,int high);

int main(){

    int merge[MAX],i,n;

    printf("Enter the total number of elements: ");
    scanf("%d",&n);

    printf("Enter the elements which to be sort: ");
    for(i=0;i<n;i++){
         scanf("%d",&merge[i]);
    }

    partition(merge,0,n-1);

    printf("After merge sorting elements are: ");
    for(i=0;i<n;i++){
         printf("%d ",merge[i]);
    }

   return 0;
}

void partition(int arr[],int low,int high){

    int mid;

    if(low<high){
         mid=(low+high)/2;
         partition(arr,low,mid);
         partition(arr,mid+1,high);
         mergeSort(arr,low,mid,high);
    }
}

void mergeSort(int arr[],int low,int mid,int high){

    int i,m,k,l,temp[MAX];

    l=low;
    i=low;
    m=mid+1;

    while((l<=mid)&&(m<=high)){

         if(arr[l]<=arr[m]){
             temp[i]=arr[l];
             l++;
         }
         else{
             temp[i]=arr[m];
             m++;
         }
         i++;
    }

    if(l>mid){
         for(k=m;k<=high;k++){
             temp[i]=arr[k];
             i++;
         }
    }
    else{
         for(k=l;k<=mid;k++){
             temp[i]=arr[k];
             i++;
         }
    }

    for(k=low;k<=high;k++){
         arr[k]=temp[k];
    }
}


↓↑ Program to evaluate postfix expression. 

#include<stdio.h>
#include<math.h>
float stack[10];
int top=-1;
void push(char);
float pop();
float eval(char [],float[]);
int main()
{
    int i=0;
    char suffix[20];
    float value[20],result;
    printf("Enter a valid postfix expression:");
    gets(suffix);
    while (suffix[i]!='\0')
    {   
     if(isalpha(suffix[i]))
     {
         fflush(stdin);
         printf("\nEnter the value of %c",suffix[i]);
         scanf("%f",&value[i]);
     }
        i++;
    }
    result=eval(suffix,value);
    printf("The result of %s=%f",suffix,result);
return 0;
}

float eval(char suffix[],float data[])
{
    int i=0;
    float op1,op2,res;
    char ch;
    while(suffix[i]!='\0')
    {
     ch=suffix[i];
     if(isalpha(suffix[i]))
     {
            push(data[i]);
     }
     else
     {
            op2=pop();
     op1=pop();
     switch(ch)
     {
         case '+' : push(op1+op2);
  break;
  case '-' : push(op1-op2);
  break;
  case '*' : push(op1*op2);
  break;
  case '/' :push(op1/op2);
  break;
  case '^' : push(pow(op1,op2));
  break;
            }
        }
    i++;
    }
    res=pop();
return(res);
}
void push(char num)
{
    top=top+1;
    stack[top]=num;
}
float pop()
{
    float num;
    num=stack[top];
    top=top-1;
return(num);
}



↓↑ Program to implement queue.

#include<stdio.h>
#define MAXSIZE 5
int front=-1, rear=-1,choice;
int q[10];
void qinsert();
void qdelete();
void qdisplay();
int main()
{
do
{
    printf("\n1-->insert\n");
    printf("2-->delete\n");
    printf("3-->display\n");
    printf("4-->exit\n");
    printf("enter your choice:");
    scanf("%d",&choice);
    switch(choice)
    {
        case 1:qinsert();
            break;
        case 2:qdelete();
            break;
        case 3:qdisplay();
            break;
        case 4:break;
    }
}while(choice!=4);
return 0;
}
void qinsert()
{
    int num;
    if(rear==(MAXSIZE-1))
    {
        printf("queue is full\n");
    return;
    }
    else
    {
        printf("enter no\n");
        scanf("%d",&num);
        rear=rear+1;
        q[rear]=num;
        if(front==-1)
        {
            front++;
        }
    }
 return;
 }
void qdelete()
{
    int num;
    if(front==-1)
    {
        printf("queue empty\n");
    return;
    }
    else
    {
    if(front==rear)
        front=rear=-1;
    else
    {
        num=q[front];
        printf("deleted item=%d",q[front]);
        front++;
    }
}
//return(num);
}
void qdisplay()
{
    int i;
    if(front==-1)
    {
        printf("queue empty\n");
    return;
    }
    else
    {
        printf("\nThe status of the queu\n");
        for(i=front;i<=rear;i++)
        {
            printf("%d\t",q[i]);
        }
    }
    printf("\n");
}


↓↑ Program to implement Quicksort. 

#include<stdio.h>
void quick(int a[],int,int);
int partition(int a[],int,int);
int main()
{
    int a[15],i,lb,hb,n;
    printf("enter no of element in array :");
    scanf("%d",&n);
    printf("enter element:");
    for(i=0;i<n;i++)
    scanf("%d",&a[i]);
    lb=0;
    hb=n-1;
    quick(a,lb,hb);
    printf("sorted array after quick sort:");
    for(i=0;i<n;i++)
    {
     printf("%d\t",a[i]);
    }
return 0;
}

void quick(int a[],int lb,int ub)
{
    int pos;
    if(lb>=ub)return;
    pos=partition(a,lb,ub);
    quick(a,lb,pos-1);
    quick(a,pos+1,ub);
}
int partition(int a[],int l,int h)
{
    int pivot,down,up,pos,temp;
    pivot=a[l];
    down=l;
    up=h;
    do
    { 
        while(pivot>=a[down])
     down++;
 while(pivot<a[up])
     up--;
 if(down<up)
 {
     temp=a[down];
     a[down]=a[up];
     a[up]=temp;
 }
    }while(down<up);

    pos=up;
    a[l]=a[pos];
    a[pos]=pivot;
return pos;
}





↓↑ Program to implement selection sort. 

#include<stdio.h>
int main()
{
    int a[15],i,j,min,n,minpos,temp;
    printf("enter no of element:");
    scanf("%d",&n);
    printf("\nenter array element:");
    for(i=0;i<n;i++)
    scanf("%d",&a[i]);
    min=a[0];
    for(i=0;i<n;i++)
    {
        min=a[i];
 minpos=i;
 for(j=i+1;j<n;j++)
 {
            if(a[j]<min)
     {
         min=a[j];
  minpos=j;
     }
            if(minpos!=i)
     {
         temp=a[i];
  a[i]=a[minpos];
  a[minpos]=temp;
            }  
 }
    }
    printf("\nsorted array is:");
    for(i=0;i<n;i++)
        printf("%d\t",a[i]);

    printf("\n");
return 0;
}


↓↑ Proram to implement stack. 

#include<stdio.h>
#include<stdlib.h>
#define MAX 10
struct student;
void push(struct student *,int);
int pop(struct student *);
void display(struct student *);
struct student
{
    int arr[MAX];
    int top;  
};
typedef struct student *ps;    
struct student s1;
int main()
{

    int n,choice;
    char ch;
    s1.top=-1;
    do{
        printf("\n1.push\n2.pop\n3.display\n0.exit\nenter choice:");
 scanf("%d",&choice);
 switch(choice)
 {
     case 1:
      printf("enter value :");
      scanf("%d",&n);
      push(&s1,n); 
     break;
     case 2:
         n=pop(&s1);
  if(n==-1)
  {
      printf("stack is empty\n");
  }
  else
      printf("popped value is:%d \n",n);
     break;
     case 3:
         display(&s1);
     break;

            case 0:
      exit(0);
     default: 
         printf("invalid choice!!!!\n");
 }
    }while(1);

return 0;
}
void push(ps p,int n)
{
    if(s1.top==MAX-1)
    printf("stack overflow\n");
    else
    p->arr[++p->top]=n;
}

int pop(ps p)
{
    if(p->top==-1)
    {
        printf("stack underflow!!!\n");
        return;
    }
return (p->arr[(p->top)--]);
}

void display(ps p)
{
    int i;

    for(i=p->top;i>=0;i--)
    {
        printf("%d ",p->arr[i]);
    }
    printf("\n");
}



↓↑ Program to implement tower of hanoi. 

#include<stdio.h>
void move(int,char,char,char);
int k=0;
int main()
{
    int n;
    printf("enter no of disc's:");
    scanf("%d",&n);
    move(n,'A','C','B');
    printf("total moves =%d\n",k);
return 0;
}

void move(int n,char src,char dest,char mid)
{
    if(n==0)
     return;
    move(n-1,src,mid,dest);
    printf("move %d from %c\n",n,src,dest);
    k++;
    move(n-1,mid,dest,src);
}


↓↑ Program to implement Binary search tree,inorder,preorder,postorder traversal. 

#include<stdio.h>
#include<malloc.h>
struct bt
{
    struct bt *left;
    int data;
    struct bt *right;
};
typedef struct bt snode;
typedef struct bt* psnode;
void insert(int);
void inorder(psnode);
void preorder(psnode);
void postorder(psnode);
int search(int);
psnode root=NULL;

int main()
{
    int ch,n;
    do 
    { 
     printf("1.insert.\n2.inorder\n3.preorder\n4.postorder\n5.search element.\n6.exit.\nenter chioce:"); 
     scanf("%d",&ch);
     switch(ch)
     {
         case 1:printf("\nenter the element to insert:");
                scanf("%d",&n);
  insert(n);
     break;
     case 2:inorder(root); printf("\n"); break;
     case 3:preorder(root);printf("\n");  break;
     case 4:postorder(root);printf("\n"); break;
     case 5:printf("enter element to search:");
         scanf("%d",&n);
  search(n);
     break;   
     case 6:break;
     default: printf("wrong choice!!!!!\n");
 }
    }while(ch!=6);
return 0;
}

void insert(int n)
{
    psnode ptr1,ptr,prev;
    ptr=(psnode)malloc(sizeof(struct bt));
    ptr->data=n;
    ptr->left=ptr->right=NULL;
    if(root==NULL)
    {
     root=ptr;return;
    }
    else
    {
        ptr1=root;
        prev=NULL;
        while(ptr1)
        {
            prev=ptr1;
            if(n< ptr1->data)
     {
         ptr1=ptr1->left;
     }
     else if(n > ptr1->data)
     {
         ptr1=ptr1->right;  
     }
        }  
        if(n>prev->data) prev->right=ptr;
        if(n<prev->data) prev->left=ptr;
    }
}

void inorder(psnode p)
{
    if(p==NULL) return; 
    inorder(p->left);
    printf("%d ",p->data); 
    inorder(p->right);
}

void preorder(psnode p)
{
    if(p==NULL)return;
    printf("%d ",p->data);
    preorder(p->left);
    preorder(p->right);
}
void postorder(psnode p)
{
    if(p==NULL)return;
    postorder(p->left);
    postorder(p->right);
    printf("%d ",p->data);
}

int search(int key)
{
    psnode ptr=root;
    while(ptr)
    {
     if(key==ptr->data)
     { 
            printf("element found.\n"); return 1;
        }
        else if(key<ptr->data)
     ptr=ptr->left;
        else
     ptr=ptr->right; 
    }
    printf("\nnot found\n");
return 0;
}


↓↑ Program for Dijkstra's single source shortest path algorithm. 

 
#include <stdio.h>
#include <limits.h>
#include <stdbool.h> 
// Number of vertices in the graph
#define V 9
 
// A utility function to find the vertex with minimum distance value, from
// the set of vertices not yet included in shortest path tree
int minDistance(int dist[], bool sptSet[])
{
    int v;
   // Initialize min value
    int min = INT_MAX, min_index;
 
    for (v = 0; v < V; v++)
        if (sptSet[v] == false && dist[v] <= min)
            min = dist[v], min_index = v;
    return min_index;
}
 
// A utility function to print the constructed distance array
int printSolution(int dist[], int n)
{
    int i;
    printf("Vertex   Distance from Source\n");
    for (i = 0; i < V; i++)
        printf("%d \t\t %d\n", i, dist[i]);
}
 
// Funtion that implements Dijkstra's single source shortest path algorithm
// for a graph represented using adjacency matrix representation
void dijkstra(int graph[V][V], int src)
{
     int i,count,v;
     int dist[V];     // The output array.  dist[i] will hold the shortest
                      // distance from src to i
 
     bool sptSet[V]; // sptSet[i] will true if vertex i is included in shortest
                     // path tree or shortest distance from src to i is finalized
 
     // Initialize all distances as INFINITE and stpSet[] as false
     for (i = 0; i < V; i++)
        dist[i] = INT_MAX, sptSet[i] = false;
 
     // Distance of source vertex from itself is always 0
     dist[src] = 0;
 
     // Find shortest path for all vertices
     for (count = 0; count < V-1; count++)
     {
       // Pick the minimum distance vertex from the set of vertices not
       // yet processed. u is always equal to src in first iteration.
       int u = minDistance(dist, sptSet);
 
       // Mark the picked vertex as processed
       sptSet[u] = true;
 
       // Update dist value of the adjacent vertices of the picked vertex.
       for (v = 0; v < V; v++)
 
         // Update dist[v] only if is not in sptSet, there is an edge from 
         // u to v, and total weight of path from src to  v through u is 
         // smaller than current value of dist[v]
         if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX 
                                       && dist[u]+graph[u][v] < dist[v])
            dist[v] = dist[u] + graph[u][v];
     }
 
     // print the constructed distance array
     printSolution(dist, V);
}
 
// driver program to test above function
int main()
{
   
   int graph[V][V] = {{0, 4, 0, 0, 0, 0, 0, 8, 0},
                      {4, 0, 8, 0, 0, 0, 0, 11, 0},
                      {0, 8, 0, 7, 0, 4, 0, 0, 2},
                      {0, 0, 7, 0, 9, 14, 0, 0, 0},
                      {0, 0, 0, 9, 0, 10, 0, 0, 0},
                      {0, 0, 4, 0, 10, 0, 2, 0, 0},
                      {0, 0, 0, 14, 0, 2, 0, 1, 6},
                      {8, 11, 0, 0, 0, 0, 1, 0, 7},
                      {0, 0, 2, 0, 0, 0, 6, 7, 0}
                     };
 
    dijkstra(graph, 0);
 
    return 0;
}


↓↑ Program to implement Heap sort. 

#include<stdio.h>
int a[15],n;
void del_root(int);
void heap_sort();
void insert(int,int);
void create_heap();

int main()
{
    int i;
    printf("Enter the No. of Elements\n");
    scanf("%d",&n);
  
    for(i=0;i<n;i++)
    {
        printf("Enter the %d Element\n",i+1);
        scanf("%d",&a[i]);
    }

    printf("\nEntered list is:");
    for(i=0;i<n;i++)
    {
        printf("%d\t",a[i]);
    }
    create_heap();
    printf("\nHeap is:");
    for(i=0;i<n;i++)
    {
        printf("%d\t",a[i]);
    }
    heap_sort();
    printf("\nSorted list is:");
  
    for(i=0;i<n;i++)
    {
        printf("%d\t",a[i]);
    }
    printf("\n");
return 0;
}

void del_root(int last)
{
    int left,right,i,temp;
    i=0;
    temp=a[i];
    a[i]=a[last];
    a[last]=temp;
  
    left=2*i+1;
    right=2*i+2;
  
    while(right<last)
    {
        if((a[i]>=a[left])&&(a[i]>=a[right]))
            return;
    
        if(a[right]<=a[left])
        {
            temp=a[i];
            a[i]=a[left];
            a[left]=temp;
            i=left;
        }
        else
        {  
            temp=a[i];
            a[i]=a[right];
            a[right]=temp;
            i=right;
        }
    
        left=2*i+1;
       right=2*i+1;
    }
    if((left==last-1)&&a[i]<a[left])
    {
        temp=a[i];
        a[i]=a[left];
        a[left]=temp;
    }
}

void heap_sort()
{
    int i=n-1;
  
    for(;i>0;i--)
    {
        del_root(i);
    }
}



void insert(int num,int loc)
{
    int parent;
    while(loc>0)
    {
        parent=(loc-1)/2;
        if(num<=a[parent])
        {
            a[loc]=num;
            return;
        }
        a[loc]=a[parent];
        loc=parent;
    }
  
    a[0]=num;
}


void create_heap()
{
    int i;
    for(i=0;i<n;i++)
    {
        insert(a[i],i);    
    }
}



↓↑ link list which makes two other list one with no's divisible by 3  other with rest 

   
#include<stdio.h>
#include<malloc.h>

struct node{
        int data;
        struct node *next;
};

struct node *start,*start1,*start2;
void display();
void create(int);
void displaydiv3();
void displaynotdiv3();
int main()
{
    int ch,n2,n3,i;
    start=start1=start2=NULL;
    do
    {
        printf("\n0.create list\n1.list of no divisible by 3.\n2.list of no not divisible by 3.\n3.display.\n4.exit\nenter choice:");
 scanf("%d",&ch);
 switch(ch)
 {
     case 0:printf("how many node you want to create:");
     scanf("%d",&n2);
     for(i=0;i<n2;i++)
     {
         printf("\nenter element:");
  scanf("%d",&n3);
  create(n3);
     }
     break;
     case 1:displaydiv3();
     break;
     case 2:displaynotdiv3();
     break;
     case 3:display();
     break;
     case 4: break;
     default:
      printf("invalid choice\n");
 }
    }while(ch!=4);

return 0;
}

void create(int m)
{
    struct node *p,*q;
    p=(struct node*)malloc(sizeof(struct node));    //complete list.
    p->data=m;
    p->next=NULL;
    if(start==NULL){ start=p;}  
    else {  q=start; while(q->next!=NULL){ q=q->next; }q->next=p; }
    if(m%3==0)
    {
        struct node *p1,*q1;
 p1=(struct node*)malloc(sizeof(struct node));                  // list with no divisible by 3.
 p1->data=m;
 p1->next=NULL;
 if(start1==NULL){ start1=p1;}  
 else {  q1=start1; while(q1->next!=NULL){ q1=q1->next; }q1->next=p1;} 
    }
    else
    {
        struct node *p2,*q2;
 p2=(struct node*)malloc(sizeof(struct node));   // list with other no which are not divisible by 3. 
 p2->data=m;
 p2->next=NULL;
 if(start2==NULL){ start2=p2;}  
 else {  q2=start2; while(q2->next!=NULL){ q2=q2->next; }q2->next=p2;} 
    }

}
void display()
{
    struct node *p;
    p=start;
    if(p==NULL){ printf("\nthere is no element in list\n");   return;}
    while(p!=NULL)
    {
        printf("%d\t",p->data);
 p=p->next;
    }
}

void displaynotdiv3()
{
    struct node *p;
    p=start2;
    if(p==NULL){ printf("\nthere is no element in list\n");   return;}
    while(p!=NULL)
    {
        printf("%d\t",p->data);
 p=p->next;
    }
}

void displaydiv3()
{
    struct node *p;
    p=start1;
    if(p==NULL){ printf("\nthere is no element in list\n");   return;}
    while(p!=NULL)
    {
        printf("%d\t",p->data);
 p=p->next;
    }
}