├── Accept n city and search for given city.c
├── Create structure accept emp no and search record
├── README.md
├── accept n number and search a perticular number
├── adjecancy list
├── adjecancy_matrix
├── binary_search1.c
├── binary_search2.c
├── bubble_sort1.c
├── bubble_sort2.c
├── bubble_sort3.c
├── check.c
├── check1.c
├── check2.c
├── city.txt
├── copy_stack
├── disp.c
├── eva.c
├── eval1.cpp
├── file.c
├── file2.c
├── file3.c
├── file4.c
├── file5.c
├── file7.c
├── file8.c
├── file_function.c
├── fun.s.c
├── fun1.c
├── fun_r.c
├── function.c
├── greater.c
├── l2.cpp
├── linear_serach_using_function.c
├── linked list
├── linked_list_menu_driven.c
├── list5.cpp
├── ls1.c
├── ls2.c
├── ls3.c
├── ls4.c
├── ls5.c
├── ls6.c
├── ls7.c
├── menu_driven_searching_sorting.c
├── menu_driven_sort1.c
├── menu_driven_structure.c
├── node1.c
├── node6.c
├── nodee.c
├── p.c
├── palindrome_string.c
├── pointer1.c
├── pointer2.c
├── pointer3.c
├── pointer4.c
├── pointer5.c
├── pointer7.c
├── pointer8.c
├── postfix.c
├── prefix.c
├── probability_search.c
├── process.c
├── quick_sort.c
├── random_number.c
├── rev.c
├── san.c
├── selection_sort1.c
├── selection_sort2.c
├── selection_sort3.c
├── selection_sort4.c
├── sen.c
├── singly-linkedlist
├── slip17_que1.cpp
├── sort.names.c
├── sort_using_function1.c
├── ss.c
├── ss1.c
├── stack1.c
├── string_stack.c
└── string_stack1.c


/Accept n city and search for given city.c:
--------------------------------------------------------------------------------
 1 | Que:
 2 | 
 3 | #include<stdio.h>
 4 | #include<string h>
 5 | int main()
 6 | {
 7 |   char a[50][50],nm[20];
 8 |   int i,n,flag=0,top,mid,bottom;
 9 |   printf("enter limit::");
10 |   scanf("%d",&n);
11 |   printf("enter n cities name in sorted order::");
12 |   for(i=0;i<n;i++)
13 |   scanf("%s",&a[i]);
14 |   printf("enter name to search::");
15 |   scanf("%s",&nm);
16 |   
17 |   top=0;
18 |   bottom=n-1;
19 |   while(top<=bottom)
20 |   {
21 |     mid=(top+bottom)/2;
22 |     if(strcmp(a[mid],nm)==0)
23 |     {
24 |       flag=1;break;
25 |     }
26 |     if(nm>a[mid])
27 |      top=mid+1;
28 |      else
29 |      bottom=mid-1;
30 |    }
31 |    if(flag==1)
32 |    printf("record is found...");
33 |    else
34 |    printf("record not found");
35 |  }
36 | 


--------------------------------------------------------------------------------
/Create structure accept emp no and search record:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 |  struct emp
 3 |  { int eno;
 4 |    char ename [20];
 5 |    float sal;
 6 |  }e1[50];
 7 |  int main()
 8 |  {
 9 |    int i,n,no,f=0,top,mid,bottom;
10 |    printf("enter limit::");
11 |    scanf("%d",&n);
12 |    for(i=0;i<n;i++)
13 |    { printf("enter emp no name and sal::");
14 |      scanf("%d%s%f",&e1[i].eno,&e1[i].ename,&e1[i].sal);
15 |    }
16 |    printf("enter emp number to search::");
17 |    scanf("%d",&no);
18 |    
19 |    top=0;bottom=n-1;
20 |    while(top<=bottom)
21 |    { mid=(top+bottom)/2;
22 |      if(e1[mid].eno==no)
23 |      { f=1;break;
24 |      }
25 |      if(no>e1[mid].eno)
26 |      top=mid+1;
27 |      else
28 |      bottom=mid-1;
29 |    }
30 |    if(f==1)
31 |    printf("emp number is found...");
32 |    else
33 |    printf("emp number is not found....");
34 |  }
35 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # c-programme


--------------------------------------------------------------------------------
/accept n number and search a perticular number:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |   int i,n,a[50],n1,f=0,top,mid,bottom;
 5 |   printf("enter limit::");
 6 |   scanf("%d",&n);
 7 |   printf("enter n nos::");
 8 |   for(i=0;i<n;i++)
 9 |   scanf("%d",&a[i]);
10 |   printf("enter number to search::");
11 |   scanf("%d",&n1);
12 |   
13 |   top=0;
14 |   bottom=n-1;
15 |   while(top<=bottom)
16 |   { 
17 |     mid=(top+bottom)/2;
18 |     if(a[mid]==n1)
19 |     { 
20 |       f=1;break;
21 |     }
22 |     if(n1>a[mid])
23 |     top=mid+1;
24 |     else
25 |     bottom=mid-1;
26 |   }
27 |   if(f==1)
28 |   printf("number is found...");
29 |   else
30 |   printf("number is not found...");
31 |   
32 | }
33 | 


--------------------------------------------------------------------------------
/adjecancy list:
--------------------------------------------------------------------------------
 1 | // Write a C program that accepts the vertices and edges of a graph. Create adjacency list.
 2 | 
 3 | #include<stdio.h>
 4 | #include<stdlib.h>
 5 | #include<malloc.h>
 6 | #define memory (struct node *)malloc(sizeof(struct node))
 7 | typedef struct node
 8 | {
 9 |     int data;
10 |     struct node *next;
11 | }node;
12 | 
13 | node *head[10];
14 | node *create(int a[10][10],int n)
15 | {
16 |     node *newnode,*temp;
17 |     int i,j;
18 |     for(i=1;i<=n;i++)
19 |     {
20 |         head[i]=NULL;
21 |         for(j=1;j<=n;j++)
22 |         {
23 |             if(a[i][j]==1)
24 |             {
25 |                 newnode=memory;
26 |                 newnode->data=j;
27 |                 newnode->next=NULL;
28 |                 if(head[i]==NULL)
29 |                 {
30 |                     head[i]=temp=newnode;
31 |                 }
32 |                 else
33 |                 {
34 |                     temp->next=newnode;
35 |                     temp=newnode;
36 |                 }
37 |             }
38 |         }
39 |     }
40 | }
41 | 
42 | void disp(int n)
43 | {
44 |     node *temp;
45 |     int i;
46 |   for(i=1;i<=n;i++)
47 |   {
48 |     printf("\nhead%d=>",i);
49 |     for(temp=head[i];temp!=NULL;temp=temp->next)
50 |     {
51 |         printf("%d->",temp->data);
52 |     }
53 |     printf("NULL...");
54 |   }
55 | }
56 | 
57 | int main()
58 | {
59 |     int n,i,j,a[10][10];
60 |     printf("enter limit::");
61 |     scanf("%d",&n);
62 |     for(i=1;i<=n;i++)
63 |     {
64 |         for(j=1;j<=n;j++)
65 |         {
66 |             a[i][j]=0;
67 |             if(i!=j)
68 |             {
69 |                 printf("enter edge between %d and %d",i,j);
70 |                 scanf("%d",&a[i][j]);
71 |             }
72 |         }
73 |     }
74 | 
75 |     create(a,n);
76 |     disp(n);
77 | }
78 | 


--------------------------------------------------------------------------------
/adjecancy_matrix:
--------------------------------------------------------------------------------
 1 | // Write a C program that accepts the vertices and edges of a graph and stores it as an adjacency matrix. Display the adjacency matrix. 
 2 | 
 3 | #include<stdio.h>
 4 | #include<stdlib.h>
 5 | int main()
 6 | {  int n,i,j,a[10][10];
 7 |     printf("enter limit::");
 8 |     scanf("%d",&n);
 9 |     for(i=1;i<=n;i++)
10 |     {
11 |         for(j=1;j<=n;j++)
12 |         {
13 |             a[i][j]=0;
14 |             if(i!=j)
15 |             {
16 |                 printf("enter edge between %d and %d",i,j);
17 |                 scanf("%d",&a[i][j]);
18 |             }
19 |         }
20 |     }
21 | 
22 |     printf("adjecancy matrix is=\n");
23 |     for(i=1;i<=n;i++)
24 |     printf("\tv%d",i);
25 | 
26 |     for(i=1;i<=n;i++)
27 |     {
28 |         printf("\nv%d",i);
29 |         for(j=1;j<=n;j++)
30 |         {
31 |             printf("\t%d",a[i][j]);
32 |         }
33 |     }
34 | 
35 | 
36 | }
37 | 


--------------------------------------------------------------------------------
/binary_search1.c:
--------------------------------------------------------------------------------
 1 | // accept n numbers and accept number tosearch using binary search using function.
 2 | 
 3 | #include<stdio.h>
 4 | int main()
 5 | {
 6 |   int a[30],i,n,mid,num,top,bottom,f=0;
 7 |   void binary_search(int a[30],int n);
 8 |   printf("enter limit::");
 9 |   scanf("%d",&n);
10 |   printf("enter n numbers::");
11 |   for(i=0;i<n;i++)
12 |   scanf("%d",&a[i]);
13 |   
14 |   binary_search(a,n);
15 | }
16 | 
17 | void binary_search(int a[30],int n)
18 | {
19 |   int num,top,mid,bottom,f=0,i;
20 |   printf("enter number tosearch::");
21 |   scanf("%d",&num);
22 |   top=0;
23 |   bottom=n-1;
24 |   while(top<=bottom)
25 |   {
26 |     mid=(top+bottom)/2;
27 |     if(a[mid]==num)
28 |     {
29 |       f=1;
30 |       break;
31 |     }
32 |   
33 |   if(num>a[mid])
34 |   top=mid+1;
35 |   else
36 |   bottom=mid-1;
37 |   }
38 |   if(f==1)
39 |   printf("number is found");
40 |   else
41 |   printf("number is not found");
42 | }
43 | 


--------------------------------------------------------------------------------
/binary_search2.c:
--------------------------------------------------------------------------------
 1 | //QUE:
 2 | //accept n cities name and search city by binary search using fuction.
 3 | #include<string.h>
 4 | #include<stdio.h>
 5 | int main()
 6 | {
 7 |   char s[20][20],nm[20];
 8 |   int i,n,f;
 9 |   int city(char s[20][20],char nm[20],int n);
10 |   printf("enter limit::");
11 |   scanf("%d",&n);
12 |   printf("accept n cities names::");
13 |   for(i=0;i<n;i++)
14 |   scanf("%s",&s[i]);
15 |   
16 |   f=city(s,nm,n);
17 |    if(f==1)
18 |   printf("city is found:");
19 |   else
20 |   printf("city is not found:");
21 |  
22 | }
23 | 
24 | int city(char s[20][20],char nm[20],int n)
25 | {
26 |   int i,top,mid,bottom,f=0;
27 |   printf("enter city name to search::");
28 |   scanf("%s",&nm);
29 |   top=0;
30 |   bottom=n-1;
31 |   while(top<=bottom)
32 |   {
33 |     mid=(top=bottom)/2;
34 |     if(strcmp(s[mid],nm)==0)
35 |     {
36 |       f=1;break;
37 |     }
38 |     if(nm>s[mid])
39 |     top=mid+1;
40 |     else
41 |     bottom=mid-1;
42 |   }
43 |   return f;
44 |   
45 | }
46 | 


--------------------------------------------------------------------------------
/bubble_sort1.c:
--------------------------------------------------------------------------------
 1 | // accept n nos and sort them using bubble sort*****
 2 | 
 3 | #include<stdio.h>
 4 | int main()
 5 | {
 6 |   int a[50],i,n,pass,t;
 7 |   printf("enter limit::");
 8 |   scanf("%d",&n);
 9 |   printf("enter n nos::");
10 |   for(i=0;i<n;i++)
11 |   scanf("%d",&a[i]);
12 |   
13 |   for(pass=1;pass<n;pass++)
14 |   {
15 |     for(i=0;i<n-pass;i++)
16 |     {
17 |        if(a[i]>a[i+1])
18 |        {
19 |           t=a[i];
20 |           a[i]=a[i+1];
21 |           a[i+1]=t;
22 |        }
23 |     }
24 |   }
25 |   printf("sorted numbers::");
26 |   for(i=0;i<n;i++)
27 |   printf("%d\t",a[i]);
28 | }
29 | 


--------------------------------------------------------------------------------
/bubble_sort2.c:
--------------------------------------------------------------------------------
 1 | //****accept n student names from user and sort them using alphabetical order using bubble sort***
 2 | 
 3 | #include<stdio.h>
 4 | #include<string.h>
 5 | int main()
 6 | {
 7 |   int i,n,pass;
 8 |   char s1[50][50],t[20];
 9 |   printf("enter limit::");
10 |   scanf("%d",&n);
11 |   printf("enter n names of student::");
12 |   for(i=0;i<n;i++)
13 |   scanf("%s",&s1[i]);
14 |   
15 |   for(pass=1;pass<n;pass++)
16 |   {
17 |     for(i=0;i<n-pass;i++)
18 |     {
19 |        if(strcmp(s1[i],s1[i+1])>0)
20 |        {
21 |          strcpy(t,s1[i]);
22 |          strcpy(s1[i],s1[i+1]);
23 |          strcpy(s1[i+1],t);
24 |        }
25 |     }
26 |   }
27 |   printf("sorted names=::");
28 |   for(i=0;i<n;i++)
29 |   printf("%s\t",s1[i]);
30 | }
31 | 


--------------------------------------------------------------------------------
/bubble_sort3.c:
--------------------------------------------------------------------------------
 1 | // create structure student accept n student info. and sort them ascending order of percentage
 2 | 
 3 | #include<stdio.h>
 4 | struct student
 5 | {
 6 |   int rno;
 7 |   char sname[20];
 8 |   float per;
 9 | }s1[100],t;
10 |  
11 |  int main()
12 |  {
13 |    int i,n, pass;
14 |    
15 |    printf("enter limit::");
16 |    scanf("%d",&n);
17 |    for(i=0;i<n;i++)
18 |    {
19 |      printf("enter rno name and per::\n");
20 |      scanf("%d%s%f",&s1[i].rno,&s1[i].sname,&s1[i].per);
21 |    }
22 |    
23 |    for(pass=1;pass<n;pass++)
24 |    {
25 |      for(i=0;i<n-pass;i++)
26 |      {
27 |        if(s1[i].per<s1[i+1].per)
28 |        {
29 |           t=s1[i];
30 |           s1[i]=s1[i+1];
31 |           s1[i+1]=t;
32 |        }
33 |      }
34 |    }
35 |    printf("\n display student info::\n");
36 |    for(i=0;i<n;i++)
37 |    {
38 |      printf("\n%d\t%s\t%f",s1[i].rno,s1[i].sname,s1[i].per);
39 |    }
40 |  }
41 | 


--------------------------------------------------------------------------------
/check.c:
--------------------------------------------------------------------------------
  1 | // convert infix expression to postfix using while loop
  2 | 
  3 | #include<stdio.h>
  4 | 
  5 | #include<string.h>
  6 | #define MAX 100
  7 |  struct stack
  8 |  {
  9 |    char a[MAX];
 10 |    int top;
 11 |  }s;
 12 |  
 13 |  void initial()
 14 |  {
 15 |    s.top=-1;
 16 |  }
 17 |  
 18 |  int isempty()
 19 |  {
 20 |     if(s.top==-1)
 21 |     return 1;
 22 |     else
 23 |     return 0;
 24 |  }
 25 |  
 26 |  int isfull()
 27 |  {
 28 |    if(s.top==MAX-1)
 29 |    return 1;
 30 |    else
 31 |    return 0;
 32 |  }
 33 |  
 34 |  void push(char ch)
 35 |  {
 36 |    if(isfull())
 37 |    printf("stack is full dont push....");
 38 |    else
 39 |    {
 40 |       s.top++;
 41 |       s.a[s.top]=ch;
 42 |    }
 43 |  }
 44 |  
 45 |  int pop()
 46 |  {
 47 |    char ch;
 48 |    if(isempty())
 49 |     return -1;
 50 |    else
 51 |    {
 52 |      ch=s.a[s.top];
 53 |      s.top--;
 54 |      return ch;
 55 |    }
 56 |  }
 57 |  
 58 |  
 59 |  int precedence(char n)
 60 |  {
 61 |     if(n=='(')
 62 |     return 0;
 63 |     if(n=='+' || n=='-')
 64 |     return 1;
 65 |     if(n=='*' || n=='/')
 66 |     return 2;
 67 |     return 0;
 68 |  
 69 |  }
 70 |  
 71 |  int main()
 72 |  {
 73 |     char ex[100];
 74 |     char *infix,x;
 75 |     printf("enter string::");
 76 |     scanf("%s",&ex);
 77 |     printf("\n");
 78 |     infix=ex;
 79 |     initial();
 80 |     while(*infix!='\0')
 81 |     {
 82 |       if(isalpha(*infix))
 83 |       printf("%c",*infix);
 84 |       else if(*infix=='(')
 85 |       push(*infix);
 86 |       else if(*infix==')')
 87 |       {
 88 |          while((x=pop())!='(')
 89 |          printf("%C",x);
 90 |       }
 91 |      else
 92 |      
 93 |      {
 94 |        while(precedence(s.a[s.top])>=precedence(*infix))
 95 |       printf("%c",pop());
 96 |       push(*infix);
 97 |      }
 98 |      infix++;
 99 |     }
100 |     while(!isempty())
101 |     printf("%c",pop());
102 |  }
103 |  
104 |  
105 |  
106 |  
107 |  
108 |  
109 |  
110 |  
111 |  
112 |  
113 |  
114 |  
115 |  
116 |  
117 |  
118 |  
119 |  
120 |  
121 |  
122 |  
123 |  
124 |  
125 |  
126 |  
127 |  
128 |  
129 |  
130 |  
131 |  
132 |  
133 |  
134 |  
135 |  
136 |  
137 | 


--------------------------------------------------------------------------------
/check1.c:
--------------------------------------------------------------------------------
  1 | //convert infix to postfix expression 
  2 | 
  3 | #include<string.h>
  4 | #include<ctype.h>
  5 | #include<stdio.h>
  6 | #define MAX 100
  7 |  struct stack
  8 |  {
  9 |    char a[MAX];
 10 |    int top;
 11 |  }s;
 12 |  
 13 |  void initial()
 14 |  {
 15 |    s.top=-1;
 16 |  }
 17 |  
 18 |  int isfull()
 19 |  {
 20 |    if(s.top==MAX-1)
 21 |    return 1;
 22 |    else
 23 |    return 0;
 24 |  }
 25 |  
 26 |  int isempty()
 27 |  {
 28 |    if(s.top==-1)
 29 |    return 1;
 30 |    else
 31 |    return 0;
 32 |  }
 33 |  
 34 |  void push(char c)
 35 |  {
 36 |    if(isfull())
 37 |    printf("stack is full dont push");
 38 |    else
 39 |    {
 40 |      s.top++;
 41 |      s.a[s.top]=c;
 42 |    }
 43 |  }
 44 |  
 45 |  int pop()
 46 |  {
 47 |    char c;
 48 |    if(isempty())
 49 |    return -1;
 50 |    else
 51 |    {
 52 |      c=s.a[s.top];
 53 |      s.top--;
 54 |      return c;
 55 |    }
 56 |  }
 57 |  
 58 |  
 59 |  int precedence(char ch)
 60 |  {
 61 |     if(ch=='(')
 62 |      return 0;
 63 |      if(ch=='+' || ch=='-')
 64 |      return 1;
 65 |      if(ch=='*' || ch=='/')
 66 |      return 2;
 67 |      if(ch=='$' || ch=='^')
 68 |      return 3;
 69 |      return 0;
 70 |   
 71 |  }
 72 |  
 73 |  int main()
 74 |  {
 75 |    char ex[100];
 76 |    char ch,*infix;
 77 |    printf("enter string::");
 78 |    scanf("%s",&ex);
 79 |    infix=ex;
 80 |    initial();
 81 |    while(*infix!='\0')
 82 |    {
 83 |      if(isalpha(*infix))
 84 |      printf("%c",*infix);
 85 |      else if(*infix=='(')
 86 |      push(*infix);
 87 |      else if(*infix==')')
 88 |      {
 89 |         while((ch=pop())!='(')
 90 |         printf("%c",ch);
 91 |      }
 92 |      else
 93 |      {
 94 |        while(precedence(s.a[s.top])>=precedence(*infix))
 95 |        printf("%c",pop());
 96 |        push(*infix);
 97 |      }
 98 |      infix++;
 99 |    }
100 |    while(!isempty())
101 |    printf("%c",pop());
102 |  } 
103 |  
104 |  
105 |  
106 |  
107 |  
108 |  
109 |  
110 |  
111 |  
112 |  
113 |  
114 |  
115 |  
116 |  
117 |  
118 |  
119 |  
120 |  
121 |  
122 |  
123 |  
124 |  
125 |  
126 |  
127 |  
128 |  
129 |  
130 |  
131 |  
132 |  
133 |  
134 |  
135 |  
136 | 


--------------------------------------------------------------------------------
/check2.c:
--------------------------------------------------------------------------------
  1 | //convert infix expression to postfix using for loop
  2 | 
  3 | #include<stdio.h>
  4 | 
  5 | #include<string.h>
  6 | #define MAX 100
  7 |  struct stack
  8 |  {
  9 |    char a[MAX];
 10 |    int top;
 11 |  }s;
 12 |  
 13 |  void initial()
 14 |  {
 15 |    s.top=-1;
 16 |  }
 17 |  
 18 |  int isempty()
 19 |  {
 20 |     if(s.top==-1)
 21 |     return 1;
 22 |     else
 23 |     return 0;
 24 |  }
 25 |  
 26 |  int isfull()
 27 |  {
 28 |    if(s.top==MAX-1)
 29 |    return 1;
 30 |    else
 31 |    return 0;
 32 |  }
 33 |  
 34 |  void push(char ch)
 35 |  {
 36 |    if(isfull())
 37 |    printf("stack is full dont push....");
 38 |    else
 39 |    {
 40 |       s.top++;
 41 |       s.a[s.top]=ch;
 42 |    }
 43 |  }
 44 |  
 45 |  int pop()
 46 |  {
 47 |    char ch;
 48 |    if(isempty())
 49 |     return -1;
 50 |    else
 51 |    {
 52 |      ch=s.a[s.top];
 53 |      s.top--;
 54 |      return ch;
 55 |    }
 56 |  }
 57 |  
 58 |  
 59 |  int precedence(char n)
 60 |  {
 61 |     if(n=='(')
 62 |     return 0;
 63 |     if(n=='+' || n=='-')
 64 |     return 1;
 65 |     if(n=='*' || n=='/')
 66 |     return 2;
 67 |     return 0;
 68 |  
 69 |  }
 70 |  
 71 |  int main()
 72 |  {
 73 |     char string[100],ch;
 74 |      int i;
 75 |     printf("enter string::");
 76 |     scanf("%s",string);
 77 |     
 78 |     initial();
 79 |     for(i=0;string[i]!='\0';i++)
 80 |     {
 81 |       if(isalpha(string[i]))
 82 |       printf("%c",string[i]);
 83 |       else if(string[i]=='(')
 84 |       push(string[i]);
 85 |       else if(string[i]==')')
 86 |       {
 87 |          while((ch=pop())!='(')
 88 |          printf("%c",ch);
 89 |       }
 90 |      else
 91 |      
 92 |      {
 93 |        while(precedence(s.a[s.top])>=precedence(string[i]))
 94 |       printf("%c",pop());
 95 |       push(string[i]);
 96 |      }
 97 |      string[i]++;
 98 |     }
 99 |     while(!isempty())
100 |     printf("%c",pop());
101 |  }
102 |  
103 |  
104 |  
105 |  
106 |  
107 |  
108 |  
109 |  
110 |  
111 |  
112 |  
113 |  
114 |  
115 |  
116 |  
117 |  
118 |  
119 |  
120 |  
121 |  
122 |  
123 |  
124 |  
125 |  
126 |  
127 |  
128 |  
129 |  
130 |  
131 |  
132 |  
133 |  
134 |  
135 |  
136 | 


--------------------------------------------------------------------------------
/city.txt:
--------------------------------------------------------------------------------
1 | shrirampur 2224
2 | nashik 8990
3 | nandgoan 666789
4 | satara 9090
5 | delhi 2345
6 | gujrat 7665
7 | 


--------------------------------------------------------------------------------
/copy_stack:
--------------------------------------------------------------------------------
 1 | //slip 2,8,17_que2
 2 | #include<stdio.h>
 3 | #define MAX 20
 4 | char data[MAX];
 5 | int top;
 6 | void init()
 7 | {
 8 | 	top=-1;
 9 | }
10 | int isempty()
11 | {
12 | 	if(top==-1)
13 | 		return 1;
14 | 	else
15 | 		return 0;
16 | }
17 | int isfull()
18 | {
19 | 	if(top==MAX-1)
20 | 		return 1;
21 | 	else
22 | 		return 0;
23 | }
24 | void push(char c)
25 | {
26 | 	if(isfull())
27 | 	{
28 | 		printf("\nStack is full dont push..");
29 | 	}
30 | 	else
31 | 	{
32 | 		top++;
33 | 		data[top]=c;
34 | 	}
35 | }
36 | char pop()
37 | {
38 | 	char c;
39 | 	if(isempty())
40 | 	{
41 | 		printf("\nStack is full dont push..");
42 | 	}
43 | 	else
44 | 	{
45 | 		c=data[top];
46 | 		top--;
47 | 		return c;
48 | 	}
49 | }
50 | int main()
51 | {
52 | 	char s1[20],s2[20],temp[20];
53 | 	int i,k=0;
54 | 	printf("Enter string:");
55 | 	gets(s1);
56 | 	init();
57 | 	for(i=0;s1[i]!='\0';i++)
58 | 	{
59 | 		push(s1[i]);
60 | 	}
61 | 	printf("\norginal stack:");
62 | 	for(i=0;s1[i]!='\0';i++)
63 | 	{
64 | 		printf("%c",s1[i]);
65 | 	}
66 | 	while(!isempty())
67 | 	{
68 | 		temp[k]=pop();
69 | 		k++;
70 | 	}
71 | 	temp[k]='\0';
72 | 	for(k=0;temp[k]!='\0';k++)
73 | 	{
74 | 		push(temp[k]);
75 | 	}
76 | 	while(!isempty())
77 | 	{
78 | 		s2[k]=pop();
79 | 		k++;
80 | 	}
81 | 	printf("\ncopied stack=");
82 | 	for(k=0;s2[k]!='\0';k++)
83 | 	{
84 | 		printf("%c",s2[k]);
85 | 	}
86 | }
87 | 


--------------------------------------------------------------------------------
/disp.c:
--------------------------------------------------------------------------------
 1 | //accept string and display using for loop
 2 | 
 3 | #include<stdio.h>
 4 | #include<string.h>
 5 | int main()
 6 | {
 7 |   char s[40]; int i;
 8 |   printf("enter string::");
 9 |   gets(s); 
10 |   //printf("string::=%s",s);
11 | 
12 |  for(i=0;s[i]!='\0';i++)
13 |  {
14 |    printf("%c",s[i]);
15 |  }
16 | }
17 | 


--------------------------------------------------------------------------------
/eva.c:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #define MAX 100
  3 |  struct stack
  4 |  {
  5 |    char a[MAX];
  6 |    int top;
  7 |  }s;
  8 |  
  9 |  void initial()
 10 |  {
 11 |    s.top=-1;
 12 |  }
 13 |  
 14 |  int isfull()
 15 |  {
 16 |    if(s.top==MAX-1)
 17 |    return 1;
 18 |    else
 19 |    return 0;
 20 |  }
 21 |  
 22 |  int isempty()
 23 |  {
 24 |    if(s.top==-1)
 25 |    return 1;
 26 |    else
 27 |    return 0;
 28 |  }
 29 |  
 30 |  void push(int c)
 31 |  {
 32 |    if(isfull())
 33 |    printf("stack is full");
 34 |    else
 35 |    {
 36 |      s.top++;
 37 |      s.a[s.top]=c;
 38 |    }
 39 |  }
 40 |  
 41 |  
 42 |  int pop()
 43 |  {
 44 |    int v;
 45 |    if(isempty())
 46 |    printf("stack is empty");
 47 |    else
 48 |    {
 49 |      v=s.a[s.top];
 50 |      s.top--;
 51 |      return v;
 52 |    }
 53 |  }
 54 |  
 55 |  int main()
 56 |  {
 57 |    char s1[50];
 58 |    int i,p,q,r,s,val1,val2,r;
 59 |    printf("enter postfix string::");
 60 |    gets(s1);
 61 |    printf("enter values of P Q R S::");
 62 |    scanf("%d%d%d%d",&p,&q,&r,&s);
 63 |    initial();
 64 |    
 65 |    for(i=0;s1[i]!='\0';i++)
 66 |    {
 67 |       if(isalpha(s1[i]))
 68 |       {
 69 |         switch(s1[i])
 70 |         {
 71 |           case 'P' : push(p);break;
 72 |           
 73 |           case 'Q' : push(q);break;
 74 |           
 75 |           case 'R' : push(r);break;
 76 |           
 77 |           case 'S' : push(s);break;
 78 |         }
 79 |       }
 80 |       else
 81 |       {
 82 |         val1=pop();
 83 |         val2=pop();
 84 |         switch(s1[i])
 85 |         {
 86 |           case '+' : r=val2+val1; break;
 87 |           
 88 |           case '-' : r=val2-val1;break;
 89 |           
 90 |           case '*' : r=val2*val1; break;
 91 |           
 92 |           case '/' : r=val2/val1; break;
 93 |         }
 94 |         push(r);
 95 |       }
 96 |    }
 97 |    printf("\n result=%d",pop());
 98 |  }
 99 |  
100 |  
101 |  
102 |  
103 |  
104 |  
105 |  
106 |  
107 |  
108 |  
109 |  
110 |  
111 |  
112 |  
113 |  
114 |  
115 |  
116 |  
117 |  
118 |  
119 |  
120 |  
121 |  
122 |  
123 |  
124 |  
125 |  
126 |  
127 |  
128 |  
129 |  
130 |  
131 |  
132 |  
133 |  
134 |  
135 |  
136 |  
137 |  
138 |  
139 |  
140 |  
141 |  
142 |  
143 | 


--------------------------------------------------------------------------------
/eval1.cpp:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<ctype.h>
  3 | #include<stdlib.h>
  4 | #include<string.h>
  5 | #define MAX 30
  6 |  struct stack
  7 | {
  8 |   int data[MAX];
  9 |   int top;
 10 | }s;
 11 | 
 12 | void init()
 13 | {
 14 |   s.top==-1;
 15 | }
 16 | 
 17 | int isfull()
 18 | {
 19 |   if(s.top==MAX-1)
 20 |     return 1;
 21 |   else
 22 |     return 0;
 23 | }
 24 | 
 25 | int isempty()
 26 | {
 27 |   if(s.top==-1)
 28 |     return 1;
 29 |   else
 30 |     return 0;
 31 | }
 32 | 
 33 | void push(char c)
 34 | {
 35 |   if(isfull())
 36 |    printf("stack is full dont push");
 37 |   else
 38 |    {
 39 |      s.top++;
 40 |      s.data[s.top]=c;
 41 |    }
 42 | }
 43 | 
 44 | char pop()
 45 | {
 46 |   char val;
 47 |  if(isempty())
 48 |    printf("stack is empty dont pop");
 49 |  else
 50 |   {
 51 |      val=s.data[s.top];
 52 |      s.top--;
 53 |       return val;
 54 |   }
 55 | }
 56 | 
 57 | int priority(char k)
 58 | {
 59 |   if(k=='(')
 60 |    return 0;
 61 |   else if(k=='+' || k=='-')
 62 |     return 1;
 63 |   else if(k=='*' || k=='/')
 64 |     return 2;
 65 |   else if(k=='$' || k=='^' || k=='@')
 66 |     return 3;
 67 | }
 68 | 
 69 | int main()
 70 | {
 71 |   char s1[20],ch,prefix[30];
 72 |    int i,p,q,r,s,result,v1,v2;
 73 |   printf("enter expression::");
 74 |    gets(s1);
 75 |    printf("enter value of pqrs");
 76 |    scanf("%d%d%d%d",&p,&q,&r,&s);
 77 |    init();
 78 |    
 79 |    for(i=0;s1[i]!='\0';i++)
 80 |    {
 81 |    	if(isalpha(s1[i]))
 82 |      {
 83 |         switch(s1[i])
 84 | 		{
 85 | 			
 86 | 	     case 'P':push(p);break;
 87 | 		 case 'Q':push(q);break;
 88 | 		 case 'R':push(r);break;
 89 | 		 case 'S':push(s);break;	
 90 | 	    }   	
 91 |      }	  
 92 | 	else
 93 | 	 {
 94 | 	 	v1=pop();
 95 | 	 	v2=pop();
 96 | 	 	switch(s1[i])
 97 | 	 	{
 98 | 	 	   case '+':result=v2+v1;
 99 | 			         break;
100 | 		   case '-':result=v2-v1;
101 | 		             break;
102 | 	 	   case '*':result=v2*v1;
103 | 			         break;
104 | 	 	   case '/':result=v2/v1;
105 | 			         break;
106 | 	
107 | 		}
108 | 		push(result);
109 | 	 }
110 |    
111 |    }
112 |    printf("\n result=%d",pop()); 
113 | }
114 | 
115 | 
116 | 
117 | 
118 | 
119 | 
120 | 
121 | 
122 | 
123 | 
124 | 
125 | 
126 | 
127 | 


--------------------------------------------------------------------------------
/file.c:
--------------------------------------------------------------------------------
 1 | //display all numbers of "number.txt" file....
 2 | 
 3 | #include<stdio.h>
 4 | #include<stdlib.h>
 5 | int main()
 6 | {
 7 |   FILE *fp1;
 8 |   int num;
 9 |   fp1=fopen("number.txt","r");
10 |   if(fp1==NULL)
11 |   {
12 |     printf("file not found");
13 |     exit(0);
14 |   }
15 |   while(!feof(fp1))
16 |   {
17 |     fscanf(fp1,"%d",&num);
18 |     printf("%d",num);
19 | 
20 |   }
21 |   fclose(fp1);
22 | }
23 | 


--------------------------------------------------------------------------------
/file2.c:
--------------------------------------------------------------------------------
 1 | //display all cities name from "cityy.txt" file....
 2 | 
 3 | #include<stdio.h>
 4 | #include<stdlib.h>
 5 | int main()
 6 | {
 7 |   FILE *fp;
 8 |   char s[40];
 9 |   fp=fopen("cityy.txt","r");
10 |   if(fp==NULL)
11 |   {
12 |     printf("file not found");
13 |     exit(0);
14 |   }
15 |   while(!feof(fp))
16 |   {
17 |     fscanf(fp,"%s",s);
18 |     printf("%s\n",s);
19 |   }
20 |   fclose(fp);
21 | }
22 | 


--------------------------------------------------------------------------------
/file3.c:
--------------------------------------------------------------------------------
 1 | //search a given number in file "number.txt" using linear search....
 2 | 
 3 | #include<stdio.h>
 4 | #include<stdlib.h>
 5 | int main()
 6 | {
 7 |   FILE *fp;
 8 |   int num,x,f=0;
 9 |   fp=fopen("number.txt","r");
10 |   if(fp==NULL)
11 |   {
12 |     printf("file not found");
13 |     exit(0);
14 |   }
15 |   printf("enter number to search::");
16 |   scanf("%d",&x);
17 |   while(!feof(fp))
18 |   {
19 |     fscanf(fp,"%d",&num);
20 |     if(num==x)
21 |     {
22 |       f=1;
23 |       break;
24 |     }
25 |   }
26 |   if(f==1)
27 |   printf("number found");
28 |   else
29 |   printf("number not found");
30 |   fclose(fp);
31 | }
32 | 


--------------------------------------------------------------------------------
/file4.c:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | #include<stdio.h>
 4 | #include<stdlib.h>
 5 | #include<string.h>
 6 | int main()
 7 | {
 8 |   FILE *fp;
 9 |   int f=0,std_code;
10 |   char s1[30],cname[30];
11 |   fp=fopen("std.txt","r");
12 |   if(fp==NULL)
13 |   {
14 |     printf("file not found");
15 |     exit(0);
16 |   }
17 |   printf("enter city to search:");
18 |   scanf("%s",&cname);
19 |   while(!feof(fp))
20 |   {
21 |     fscanf(fp,"%s%d",&s1,&std_code);
22 |     if(strcmp(s1,cname)==0)
23 |     {
24 |       f=1;
25 |       break;
26 |     }
27 |   }
28 |   if(f==1)
29 |   printf("city found\n std code=%d",std_code);
30 |   else
31 |   printf("city not found in file");
32 |   fclose(fp);
33 |   
34 | }
35 | 


--------------------------------------------------------------------------------
/file5.c:
--------------------------------------------------------------------------------
 1 | //accept n numbers from file "num.txt" and cheach number found or not using function...
 2 | 
 3 | #include<stdio.h>
 4 | #include<stdlib.h>
 5 | int main()
 6 | {
 7 |   FILE *fp;
 8 |   int n,num,f=0,number,i=0,a[30],ans;
 9 |   int file(int a[30],int n,int number);
10 |   fp=fopen("num.txt","r");
11 |   if(fp==NULL)
12 |   {
13 |     printf("file not found");
14 |     exit(0);
15 |   }
16 |   while(!feof(fp))
17 |   {
18 |     fscanf(fp,"%d",&num);
19 |     a[i++]=num;
20 |   }
21 |   n=i;
22 |   printf("enter number to search::");
23 |   scanf("%d",&number);
24 |   ans=file(a,n,number);
25 |   if(ans==1)
26 |   printf("number found");
27 |   else
28 |   printf("not found");
29 |   fclose(fp);
30 |   }
31 |   
32 |   int file(int a[30],int n,int number)
33 |   { int top,mid,bottom,f=0;
34 |   top=0;
35 |   bottom=n-1;
36 |   while(top<=bottom)
37 |   {
38 |     mid=(top+bottom)/2;
39 |     if(number==a[mid])
40 |     {
41 |       f=1;
42 |       break;
43 |     }
44 |     if(number>a[mid])
45 |     top=mid+1;
46 |     else
47 |     bottom=mid-1;
48 |   }
49 |    return f;
50 |   
51 | }
52 | 


--------------------------------------------------------------------------------
/file7.c:
--------------------------------------------------------------------------------
 1 | //accept n number from file "num.txt" and check number is found or not using binary search....
 2 | 
 3 | #include<stdio.h>
 4 | #include<stdlib.h>
 5 | int main()
 6 | {
 7 |   FILE *fp;
 8 |   int num,number,n,f=0,i=0,a[100],top,mid,bottom;
 9 |   fp=fopen("num.txt","r");
10 |   if(fp==NULL)
11 |   {
12 |     printf("file not found");
13 |     exit(0);
14 |   }
15 |   while(!feof(fp))
16 |   {
17 |     fscanf(fp,"%d",&num);
18 |     a[i++]=num;
19 |   }
20 |   n=i;
21 |   printf("enter number to search:");
22 |   scanf("%d",&number);
23 |   top=0;
24 |   bottom=n-1;
25 |   while(top<=bottom)
26 |   {
27 |     mid=(top+bottom)/2;
28 |     if(number==a[mid])
29 |     {
30 |       f=1;
31 |       break;
32 |     }
33 |     if(number>a[mid])
34 |     top=mid+1;
35 |     else
36 |     bottom=mid-1;
37 |   }
38 |   if(f==1)
39 |   printf("number is found");
40 |   else
41 |   printf("number is not found");
42 |   fclose(fp);
43 | }
44 | 


--------------------------------------------------------------------------------
/file8.c:
--------------------------------------------------------------------------------
 1 | //accept city name and std code and accept city for search if city found print their std code using binary search....
 2 | 
 3 | #include<stdio.h>
 4 | #include<stdlib.h>
 5 | #include<string.h>
 6 |  struct city
 7 |  {
 8 |    char cname[20];
 9 |    int std_code;
10 |  }c1[30];
11 |  
12 |  int main()
13 |  {
14 |    FILE *fp;
15 |    int n,code,i=0,f=0,top,mid,bottom;
16 |    char name[20],x[20];
17 |    fp=fopen("sort_city.txt","r");
18 |    if(fp==NULL)
19 |    {
20 |     printf("file not found");
21 |     exit(0);
22 |    }
23 |    while(!feof(fp))
24 |    {
25 |      fscanf(fp,"%s%d",&name,&code);
26 |      strcpy(c1[i].cname,name);
27 |      c1[i].std_code=code;
28 |      i++;
29 |    }
30 |    n=i;
31 |    printf("enter city name to search::");
32 |    scanf("%s",&x);
33 |    
34 |    top=0;
35 |    bottom=n-1;
36 |    while(top<=bottom)
37 |    {
38 |      mid=(top+bottom)/2;
39 |       if(strcmp(c1[mid].cname,x)==0)
40 |       {
41 |         f=1;
42 |         break;
43 |       }
44 |       if(strcmp(x,c1[mid].cname)>0)
45 |       top=mid+1;
46 |       else
47 |       bottom=mid-1;
48 |    }
49 |    if(f==1)
50 |    printf("city found\n std code=%d",c1[mid].std_code);
51 |    else
52 |    printf("city not in the list");
53 |    fclose(fp);
54 |  }
55 | 


--------------------------------------------------------------------------------
/file_function.c:
--------------------------------------------------------------------------------
 1 | //strucutre file using function
 2 | 
 3 | #include<stdio.h>
 4 | #include<stdlib.h>
 5 | #include<string.h>
 6 |  struct city
 7 |  {
 8 |    char cname[20];
 9 |    int std_code;
10 |  }c1[30];
11 |  
12 |  int main()
13 |  {
14 |    FILE *fp;
15 |    int n,i=0,ans,mid,top,bottom,code;
16 |    char name[20],x[20];
17 |    int file(struct city c1[30],int n,char x[20]);
18 |    fp=fopen("cc.txt","r");
19 |    if(fp==NULL)
20 |    {
21 |     printf("file not found");
22 |     exit(0);
23 |    }
24 |    while(!feof(fp))
25 |    {
26 |      fscanf(fp,"%s%d",name,&code);
27 |      strcpy(c1[i].cname,name);
28 |      c1[i].std_code=code;
29 |      i++;
30 |    }
31 |    n=i;
32 |    printf("enter city name to search::");
33 |    scanf("%s",x);
34 |    ans=file(c1,n,x);
35 |    if(ans==1)
36 |    printf("std code=%d",c1[mid].std_code);
37 |    else
38 |    printf("city not in list:");
39 |    fclose(fp);
40 |    }
41 |    
42 |   int file(struct city c1[20],int n, char x[20])  
43 |   { int top,mid,bottom,f=0;
44 |    top=0;
45 |    bottom=n-1;
46 |    while(top<=bottom)
47 |    {
48 |      mid=(top+bottom)/2;
49 |       if(strcmp(c1[mid].cname,x)==0)
50 |       {
51 |         f=1;
52 |         break;
53 |       }
54 |       if(strcmp(x,c1[mid].cname)>0)
55 |       top=mid+1;
56 |       else
57 |       bottom=mid-1;
58 |    }
59 |   return f;
60 |  }
61 | 


--------------------------------------------------------------------------------
/fun.s.c:
--------------------------------------------------------------------------------
 1 | //accept n student names from user and display ascending order using selection sort...
 2 | #include<string.h>
 3 | #include<stdio.h>
 4 | 
 5 |  void selection(char name[20][20],int n)
 6 |  { char min[20],t[20];
 7 |  int i,j,index; 
 8 |   for(i=0;i<n;i++)
 9 |   {
10 |      strcpy(min,name[i]);
11 |      index=i;
12 |      for(j=i;j<n;j++)
13 |      {
14 |         if(strcmp(name[j],min)<0)
15 |         {
16 |           strcpy(min,name[j]);
17 |           index=j;
18 |         }
19 |      }
20 |      strcpy(t,name[i]);
21 |      strcpy(name[i],name[index]);
22 |      strcpy(name[index],t);
23 |      
24 |   }
25 |   
26 | 
27 | }
28 | 
29 | int main()
30 | {
31 |   int i,j,n,index;
32 |   char name[20][20],t[20],min[30];
33 |   printf("enter limit::");
34 |   scanf("%d",&n);
35 |   printf("enter n students names::");
36 |   for(i=0;i<n;i++)
37 |   scanf("%s",&name[i]);
38 |   selection(name,n);
39 |   
40 |   printf("sorted names::\n");
41 |   for(i=0;i<n;i++)
42 |   {
43 |   printf("%s\t",name[i]);
44 |   
45 |   }
46 |   }
47 | 


--------------------------------------------------------------------------------
/fun1.c:
--------------------------------------------------------------------------------
 1 | //accept n student names from user and display ascending order using selection sort...
 2 | #include<string.h>
 3 | #include<stdio.h>
 4 | 
 5 |  char selection(char name[20][20],int n)
 6 |  { char min[20],t[20];
 7 |  int i,j,index; 
 8 |   for(i=0;i<n;i++)
 9 |   {
10 |      strcpy(min,name[i]);
11 |      index=i;
12 |      for(j=i;j<n;j++)
13 |      {
14 |         if(strcmp(name[j],min)<0)
15 |         {
16 |           strcpy(min,name[j]);
17 |           index=j;
18 |         }
19 |      }
20 |      strcpy(t,name[i]);
21 |      strcpy(name[i],name[index]);
22 |      strcpy(name[index],t);
23 |      
24 |   }
25 |    printf("sorted names::\n");
26 |   for(i=0;i<n;i++)
27 |   {
28 |   printf("%s\t",name[i]);
29 |   
30 |   }
31 |   
32 | 
33 | }
34 | 
35 | int main()
36 | {
37 |   int i,j,n,index,ans;
38 |   char name[20][20],t[20],min[30];
39 |   printf("enter limit::");
40 |   scanf("%d",&n);
41 |   printf("enter n students names::");
42 |   for(i=0;i<n;i++)
43 |   scanf("%s",&name[i]);
44 |  ans= selection(name,n);
45 |   
46 |  
47 |   }
48 | 


--------------------------------------------------------------------------------
/fun_r.c:
--------------------------------------------------------------------------------
 1 | //accept n random number and check number found or not using function....
 2 | 
 3 | #include<stdio.h>
 4 | #include<time.h>
 5 | #include<math.h>
 6 | 
 7 | void r(int a[30],int n)
 8 | {
 9 |  int num,i;
10 |  a[i]=rand()%100;
11 |  
12 |  printf("random nos::\n");
13 |   for(i=0;i<n;i++)
14 |   printf("%d\t",a[i]);
15 |   
16 |    printf("enter no to search::");
17 |   scanf("%d",&num);
18 |   for(i=0;i<n;i++)
19 |   {
20 |     if(a[i]==num)
21 |     break;
22 |   }
23 |   if(i==n)
24 |   printf("nos not found");
25 |   else 
26 |   printf("nos is found=%d",i);
27 | }
28 | 
29 | int main()
30 | {
31 |   int i,n,a[100];
32 |   printf("enter limit::");
33 |   scanf("%d",&n);
34 |   r(a,n);
35 | }
36 | 


--------------------------------------------------------------------------------
/function.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | 
 4 | int main()
 5 | {
 6 |   int a[100],i,n,num,flag;
 7 |   int file(int a[30],int n ,int num);
 8 |   
 9 |   printf("enter limit:");
10 |   scanf("%d",&n);
11 |   printf("enter number in sorted order:");
12 |   for(i=0;i<n;i++)
13 |   scanf("%d",&a[i]);
14 |   
15 |   printf("enter number to search::");
16 |   scanf("%d",&num);
17 |   
18 |   flag=file(a,n,num);
19 |   if(flag==1)
20 |   printf("number is found");
21 |   else
22 |   printf("not found");
23 | }
24 | int file(int a[80],int n,int num)
25 | {
26 |    int top,mid,bottom,flag=0;
27 |    top=0;
28 |    bottom=n-1;
29 |    while(top<=bottom)
30 |    {
31 |      mid=(top+bottom)/2;
32 |      {
33 |       flag=1;
34 |       break;
35 |      }
36 |      if(num>a[mid])
37 |      top=mid+1;
38 |      else
39 |      bottom=mid-1;
40 |    }
41 |    return flag;
42 | }
43 | 


--------------------------------------------------------------------------------
/greater.c:
--------------------------------------------------------------------------------
 1 | //accept string and display greater string....
 2 | 
 3 | #include<stdio.h>
 4 | #include<string.h>
 5 | int main()
 6 | {
 7 |   char s1[40],s2[40];
 8 |   int i,c1=0,c2=0;
 9 |   printf("enter first string::");
10 |   gets(s1);
11 |   printf("enter second string::");
12 |   gets(s2);
13 |   
14 |   for(i=0;s1[i]!='\0';i++)
15 |    c1++;
16 |    
17 |    for(i=0;s2[i]!='\0';i++)
18 |     c2++;
19 |     
20 |     if(c1>c2)
21 |     printf("first string is greater::%s",s1);
22 |     else
23 |     printf("second string is greater::%s",s2);
24 | }
25 | 


--------------------------------------------------------------------------------
/l2.cpp:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<stdlib.h>
  3 | 
  4 |  struct node
  5 |  {
  6 |    int data;
  7 |    struct node *next;
  8 |  };
  9 | struct node* create(struct node *list)
 10 | {    int i,n;
 11 | 	struct node *newnode,*temp;
 12 | 	printf("enter limit::");
 13 | 	scanf("%d",&n);
 14 | 	
 15 | 	for(i=0;i<n;i++)
 16 | 	
 17 |    {
 18 | 	newnode=(struct node*)malloc(sizeof(struct node));
 19 | 	printf("enter value::");
 20 | 	scanf("%d",&newnode->data);
 21 | 	newnode->next=NULL;
 22 | 	if(list==NULL)
 23 | 	{
 24 | 	  list=newnode;
 25 | 	  temp=newnode;
 26 | 	}
 27 | 	else
 28 | 	{
 29 | 	  temp->next=newnode;
 30 | 	  temp=newnode;	
 31 | 	}
 32 |   }
 33 | 	return list;
 34 | }
 35 | 
 36 | void display(struct node *list)
 37 | {
 38 |    struct node *temp;
 39 |    for(temp=list;temp!=NULL;temp=temp->next)
 40 |    printf("%d\t",temp->data);
 41 | }
 42 | 
 43 | struct node *insertbeg(struct node *list,int n)
 44 | {
 45 | 	struct node *newnode;
 46 | 	
 47 | 	newnode=(struct node*)malloc(sizeof(struct node));
 48 | 	newnode->data=n;
 49 | 	newnode->next=list;
 50 | 	list=newnode;
 51 | 	return list;
 52 | }
 53 | 
 54 | struct node *insertend(struct node *list,int n)
 55 | {
 56 | 	struct node *newnode,*temp;
 57 | 	
 58 | 	newnode=(struct node*)malloc(sizeof(struct node));
 59 | 	newnode->data=n;
 60 | 	newnode->next=NULL;
 61 | 	for(temp=list;temp->next!=NULL;temp=temp->next);
 62 | 	temp->next=newnode;
 63 | 	return list;
 64 | }
 65 | 
 66 | struct node *insertmid(struct node *list,int n,int p)
 67 | {    int i;
 68 | 	struct node *newnode,*temp;
 69 | 	
 70 | 	newnode=(struct node*)malloc(sizeof(struct node));
 71 | 	newnode->data=n;
 72 | 	for(i=1,temp=list;(i<p-1 && temp->next!=NULL);i++,temp=temp->next);
 73 | 	newnode->next=temp->next;
 74 | 	temp->next=newnode;
 75 | 	return list;
 76 | }
 77 | 
 78 | struct node *delbeg(struct node *list)
 79 | {
 80 | 	struct node *temp;
 81 | 	temp=list;
 82 | 	list=list->next;
 83 | 	free(temp);
 84 | 	return list;
 85 | }
 86 | 
 87 | int main()
 88 | {    int n,ch,p;
 89 | 
 90 | 
 91 | 	 struct node *list=NULL;
 92 | 	 do
 93 | 	 {
 94 | 	 printf("1=create\n2=display\n3=insert begin\n4=insert end\n5=inser middle\n6=delete first\nenter your choice::");
 95 | 	 scanf("%d",&ch);
 96 | 	 switch(ch)
 97 | 	 {
 98 | 
 99 | 	  case 1 : list=create(list); break;
100 | 	  case 2 : display(list); break;
101 | 	  case 3 :printf("enter number::");
102 | 	          scanf("%d",&n);
103 | 			  list=insertbeg(list,n);
104 | 			  break;
105 | 	  case 4 :printf("enter number::");
106 | 	          scanf("%d",&n);
107 | 	          list=insertend(list,n);
108 | 	          break;
109 | 	 case 5 :printf("enter number::");
110 | 	         scanf("%d",&n);
111 | 	         printf("enter position::");
112 | 	         scanf("%d",&p);
113 | 	         list=insertmid(list,n,p);
114 | 	         break;
115 | 	 case 6 : list=delbeg(list);
116 | 	          break;
117 |      }
118 |    }while(ch<7);
119 | }
120 | 
121 | 


--------------------------------------------------------------------------------
/linear_serach_using_function.c:
--------------------------------------------------------------------------------
 1 | //accept number and search using linear search using function....
 2 | 
 3 | #include<stdio.h>
 4 | int main()
 5 | {
 6 |   int a[30],i,n;
 7 |   void linear(int a[100],int n);
 8 |   printf("enter limit::");
 9 |   scanf("%d",&n);
10 |   printf("enter n number::");
11 |   for(i=0;i<n;i++)
12 |   scanf("%d",&a[i]);
13 |  
14 |   
15 |   linear(a,n);
16 | }
17 | 
18 | void linear(int a[120],int n)
19 | {
20 |   int i,flag=0,num;
21 |   printf("enter number to search::");
22 |   scanf("%d",&num);
23 |   for(i=0;i<n;i++)
24 |   {
25 |     if(a[i]==num)
26 |     {
27 |       flag=1;break;
28 |     }
29 |   }
30 |   if(flag==1)
31 |   printf("number is found");
32 |   else
33 |   printf("number is not found");
34 | }
35 | 


--------------------------------------------------------------------------------
/linked list:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 |  struct node
 3 | {
 4 |    int data;
 5 |  struct node *next;
 6 | };
 7 | 
 8 | struct node *newnode;
 9 | newnode=(struct node *)malloc(sizeof(struct node));
10 | printf("enter value::");
11 | scanf("%d",*newnode->data);
12 | newnode->next==NULL;
13 | 


--------------------------------------------------------------------------------
/linked_list_menu_driven.c:
--------------------------------------------------------------------------------
  1 | //linked list menu driven
  2 | //1-create 2-display 
  3 | //3-if position =1 then insert at beginning otherwise insert middle
  4 | //4 delete n perticular code
  5 | //5-search a given numbrer in linkedlist and return node if found else return NULL.
  6 | 
  7 | 
  8 | #include<stdio.h>
  9 | #include<stdlib.h>
 10 | #include<malloc.h>
 11 |  struct node 
 12 |  {
 13 |    int data;
 14 |    struct node *next;
 15 |  };
 16 |  
 17 |  struct node * create(struct node *head)
 18 |  {
 19 |    struct node *newnode,*temp;
 20 |    int i,n;
 21 |    printf("enter limit:");
 22 |    scanf("%d",&n);
 23 |    for(i=1;i<=n;i++)
 24 |    {
 25 |      newnode=(struct node *)malloc(sizeof(struct node));
 26 |      printf("enter values::");
 27 |      scanf("%d",&newnode->data);
 28 |      newnode->next=NULL;
 29 |      if(head==NULL)
 30 |      {
 31 |        head=temp=newnode;
 32 |      }
 33 |      else
 34 |      {
 35 |       temp->next=newnode;
 36 |       temp=newnode;
 37 |      }
 38 |    }
 39 |    return head;
 40 |  }
 41 |  
 42 |  void display(struct node *head)
 43 |  {
 44 |    struct node *temp;
 45 |    for(temp=head;temp!=NULL;temp=temp->next)
 46 |    {
 47 |      printf("%d\t",temp->data);
 48 |    }
 49 |  }
 50 |  
 51 |  struct node * insert(struct node *head,int n,int p)
 52 |  {
 53 |    struct node *newnode,*temp;
 54 |    int i;
 55 |    newnode=(struct node *)malloc(sizeof(struct node));
 56 |    newnode->data=n;
 57 |    
 58 |    if(p==1)
 59 |    {
 60 |       newnode->next=head;
 61 |       head=newnode;
 62 |    }
 63 |    else
 64 |    {
 65 |      for(i=1,temp=head;i<(p-1)&&temp->next!=NULL;i++,temp=temp->next);
 66 |      newnode->next=temp->next;
 67 |      temp->next=newnode;
 68 |    }
 69 |    return head;
 70 |  }
 71 |  
 72 |  
 73 |  
 74 |  struct node *del(struct node *head,int p)
 75 |  {
 76 |     struct node *temp,*temp1;
 77 |     int i;
 78 |     
 79 |     if(p==1)
 80 |     {
 81 |       temp=head;
 82 |       head=head->next;
 83 |       free(temp);
 84 |     }
 85 |     else
 86 |     {
 87 |       for(i=1,temp=head;i<(p-1)&&temp->next!=NULL;temp=temp->next,i++);
 88 |       temp1=temp->next;
 89 |       temp->next=temp1->next;
 90 |       free(temp1);
 91 |     }
 92 |     return head;
 93 |  }
 94 |  
 95 |  struct node * search(struct node *head,int n)
 96 |  {
 97 |    struct node *temp;
 98 |    for(temp=head;temp!=NULL;temp=temp->next)
 99 |    {
100 |       if(temp->data==n)
101 |       return temp;
102 |    }
103 |    return NULL;
104 |  }
105 |  
106 |  int main()
107 |  {
108 |    int ch,n,pos;
109 |    struct node *head=NULL;
110 |    do
111 |    {
112 |       printf("\nmenu\n1=create\n2=display\n3=insert\n4=delete\n5=search\n");
113 |       printf("enter choice::");
114 |       scanf("%d",&ch);
115 |       switch(ch)
116 |       {
117 |         case 1 : head=create(head);
118 |                    break;
119 |         case 2 : display(head);
120 |                    break;
121 |         case 3 : printf("enter number::");
122 |                  scanf("%d",&n);
123 |                  printf("enter position::");
124 |                  scanf("%d",&pos);
125 |                  head=insert(head,n,pos);
126 |                  break;
127 |         case 4 : printf("enter position::");
128 |                  scanf("%d",&pos);
129 |                  head=del(head,pos);
130 |                  break;
131 |        case 5 : printf("enter number::");
132 |                  scanf("%d",&n);
133 |                  if(search(head,n)!=NULL)
134 |                  printf("number is found");
135 |                  else
136 |                  printf("number not found");
137 |                  break;
138 |       default : printf("invalide choice");
139 |       
140 |                    
141 |                   
142 |       }
143 |    }while(ch<6);
144 |  }
145 |  
146 |  
147 |  
148 |  
149 |  
150 |  
151 |  
152 |  
153 |  
154 |  
155 |  
156 |  
157 |  
158 |  
159 |  
160 |  
161 |  
162 |  
163 |  
164 |  
165 |  
166 |  
167 |  
168 |  
169 |  
170 |  
171 |  
172 |  
173 |  
174 |  
175 |  
176 |  
177 |  
178 |  
179 |  
180 | 


--------------------------------------------------------------------------------
/list5.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | 
 4 |  struct node
 5 |  {
 6 |    int data;
 7 |    struct node *next;
 8 |  };
 9 | struct node* create(struct node *list)
10 | {    int i,n;
11 | 	struct node *newnode,*temp;
12 | 	printf("enter limit::");
13 | 	scanf("%d",&n);
14 | 	
15 | 	for(i=0;i<n;i++)
16 | 	
17 |    {
18 | 	newnode=(struct node*)malloc(sizeof(struct node));
19 | 	printf("enter value::");
20 | 	scanf("%d",&newnode->data);
21 | 	newnode->next=NULL;
22 | 	if(list==NULL)
23 | 	{
24 | 	  list=newnode;
25 | 	  temp=newnode;
26 | 	}
27 | 	else
28 | 	{
29 | 	  temp->next=newnode;
30 | 	  temp=newnode;	
31 | 	}
32 |   }
33 | 	return list;
34 | }
35 | 
36 | void display(struct node *list)
37 | {
38 |    struct node *temp;
39 |    for(temp=list;temp!=NULL;temp=temp->next)
40 |    printf("%d\t",temp->data);
41 | }
42 | 
43 | struct node *insertbeg(struct node *list,int n)
44 | {
45 | 	struct node *newnode;
46 | 	
47 | 	newnode=(struct node*)malloc(sizeof(struct node));
48 | 	newnode->data=n;
49 | 	newnode->next=list;
50 | 	list=newnode;
51 | 	return list;
52 | }
53 | 
54 | int main()
55 | {    int n,ch;
56 | 
57 | 
58 | 	 struct node *list=NULL;
59 | 	 do
60 | 	 {
61 | 	 printf("1=create\n2=display\n3=insert begin\nenter your choice::");
62 | 	 scanf("%d",&ch);
63 | 	 switch(ch)
64 | 	 {
65 | 
66 | 	  case 1 : list=create(list); break;
67 | 	  case 2 : display(list); break;
68 | 	  case 3 :printf("enter number::");
69 | 	          scanf("%d",&n);
70 | 			  list=insertbeg(list,n);
71 | 			  break;
72 |      }
73 |    }while(ch<4);
74 | }
75 | 


--------------------------------------------------------------------------------
/ls1.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | void main()
 3 | {
 4 |   int n,i,a[50],num;
 5 |   printf("enter limit:");
 6 |   scanf("%d",&n);
 7 |   printf("enter n nos::");
 8 |   for(i=0;i<n;i++)
 9 |   scanf("%d",&a[i]);
10 |   printf("enter number to search:");
11 |   scanf("%d",&num);
12 |   for(i=0;i<n;i++)
13 |   {
14 |     if(a[i]==num)
15 |     break;
16 |   }
17 |   if(i==n)
18 |   printf("record not found");
19 |   else
20 |   printf("record is found");
21 | }
22 | 


--------------------------------------------------------------------------------
/ls2.c:
--------------------------------------------------------------------------------
 1 | //accept n nos randomly and printf them also check number is present n that random array or not....
 2 | 
 3 | #include<stdio.h>
 4 | #include<math.h>
 5 | #include<time.h>
 6 | void main()
 7 | {
 8 |   int n,i,num,a[200];
 9 |   printf("enter limit:");
10 |   scanf("%d",&n);
11 |   for(i=0;i<n;i++)
12 |   a[i]=rand()%100;
13 |   printf("random nos::\n");
14 |   for(i=0;i<n;i++)
15 |   printf("%d\t",a[i]);
16 |   
17 |   printf("enter no to search::");
18 |   scanf("%d",&num);
19 |   for(i=0;i<n;i++)
20 |   {
21 |     if(a[i]==num)
22 |     break;
23 |   }
24 |   if(i==n)
25 |   printf("nos not found");
26 |   else 
27 |   printf("nos is found");
28 |   
29 | }
30 | 


--------------------------------------------------------------------------------
/ls3.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 |  struct student
 4 |  {
 5 |    int rno;
 6 |    char sname[20];
 7 |    float per;
 8 |  }s1[50];
 9 |  void main()
10 |  {
11 |    int i,n,flag=0;
12 |    char name[20];
13 |    printf("enter limit:");
14 |    scanf("%d",&n);
15 |    for(i=0;i<n;i++)
16 |    {
17 |     printf("enter rno name and per::");
18 |     scanf("%d%s%f",&s1[i].rno,&s1[i].sname,&s1[i].per);
19 |    }
20 |   printf("enter name to search::");
21 |   scanf("%s",name);
22 |   for(i=0;i<n;i++)
23 |   {
24 |     if(strcmp(s1[i].sname,name)==0)
25 |     {
26 |        flag=1;
27 |        break;
28 |     }
29 |   }
30 |   if(flag==1)
31 |   {
32 |     printf("\nroll no=%d",s1[i].rno);
33 |     printf("\nname=%s",s1[i].sname);
34 |     printf("\nper=%f",s1[i].per);
35 |   }
36 |   else
37 |   printf("record not found");
38 |  }
39 | 


--------------------------------------------------------------------------------
/ls4.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | void main()
 3 | {
 4 |   int a[100],b[100],i,n;
 5 |   printf("enter limit:");
 6 |   scanf("%d",&n);
 7 |   printf("enter n nos:");
 8 |   for(i=0;i<n;i++)
 9 |   scanf("%d",&a[i]);
10 |   
11 |   
12 |   for(i=0;i<n;i++)
13 |   {
14 |     strcpy(a[i],b[i]);
15 |    
16 |   }
17 |   
18 |   printf("first array ::");
19 |   for(i=0;i<n;i++)
20 |  printf("%d\t",a[i]);
21 |  
22 |  printf("second array::");
23 |  for(i=0;i<n;i++)
24 |  printf("%d\t",b[i]);
25 | }
26 | 


--------------------------------------------------------------------------------
/ls5.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | void main()
 3 | {
 4 |   int a[100],i,n,num,cnt=0;
 5 |   printf("enter limit:");
 6 |   scanf("%d",&n);
 7 |   printf("enter n nos:");
 8 |   for(i=0;i<n;i++)
 9 |   scanf("%d",&a[i]);
10 |   
11 |   printf("enter num to search:");
12 |   scanf("%d",&num);
13 |   for(i=0;i<n;i++)
14 |   {
15 |      if(a[i]==num)
16 |      cnt++;
17 |   }
18 |   printf("number count=%d",cnt);
19 | }
20 | 


--------------------------------------------------------------------------------
/ls6.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | void main()
 4 | {
 5 |   FILE *f1;
 6 |   int f=1,code;
 7 |   char name[20],cname[20];
 8 |   
 9 |   f1=fopen("city.txt","r");
10 |   if(f1==NULL)
11 |   {
12 |     printf("file not found");
13 |     exit(0);
14 |   }
15 |   
16 |  printf("enter city name to search:");
17 |  scanf("%s",&cname);
18 |  
19 |  while(!feof(f1))
20 |  {
21 |    fscanf(f1,"%s%d",&name,&code);
22 |    if(strcmp(name,cname)==0)
23 |    {
24 |    f=0;
25 |    break;
26 |    }
27 |  }
28 |  fclose(f1);
29 |  
30 |  if(f==0)
31 |  printf("STD CODE=%d",code);
32 |  else
33 |  printf("city not found");
34 | }
35 | 


--------------------------------------------------------------------------------
/ls7.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | void main()
 3 | {
 4 |   int a[50],i,n,max1,max2;
 5 |   printf("enter limit:");
 6 |   scanf("%d",&n);
 7 |   printf("enter n numbers:");
 8 |   for(i=0;i<n;i++)
 9 |   scanf("%d",&a[i]);
10 |   
11 |   max1=a[0];
12 |   
13 |   for(i=0;i<n;i++)
14 |   {
15 |     if(a[i]>max1)
16 |     max1=a[i];
17 |    }
18 |   printf(" first maximum nos =%d",max1);
19 |   max2=a[0];
20 |   for(i=0;i<n;i++)
21 |   {
22 |     if(a[i]>max2)
23 |     {
24 |       if(a[i]!=max1)
25 |       max2=a[i];
26 |     }
27 |   }
28 |   
29 |  printf("second max no=%d",max2);
30 | }
31 | 


--------------------------------------------------------------------------------
/menu_driven_searching_sorting.c:
--------------------------------------------------------------------------------
  1 | //menu driven sorting and search program using function..
  2 | //1-linaer search 2-bubble 3-selection 4-inserton
  3 | 
  4 | #include<stdio.h>
  5 | int main()
  6 | {
  7 |   int a[20],i,n,num,ch;
  8 |   void linear(int a[20],int n,int num);
  9 |   void bubble(int a[20],int n);
 10 |   void selection(int a[20],int n);
 11 |   void insertion(int a[20],int n);
 12 |   printf("enter limit::");
 13 |   scanf("%d",&n);
 14 |   printf("enter n nos::");
 15 |   for(i=0;i<n;i++)
 16 |   scanf("%d",&a[i]);
 17 |   
 18 |   do
 19 |   {
 20 |     printf("\n menu=\n1-linear search\n2-bubble sort\n3-selection sort\n4-insertion\n enter your choice::");
 21 |     scanf("%d",&ch);
 22 |     switch(ch)
 23 |     {
 24 |       case 1 : printf("enter number to search::");
 25 |                scanf("%d",&num);
 26 |                linear(a,n,num);
 27 |                break;
 28 |       case 2 : bubble(a,n);
 29 |                break;
 30 |       case 3 : selection(a,n);
 31 |                break;
 32 |       case 4 : insertion(a,n);
 33 |                break;
 34 |       default : printf("invalid choice::");
 35 |                 break; 
 36 |     }
 37 |   }while(ch<5);
 38 |  }
 39 |  
 40 |  void linear(int a[20],int n, int num)
 41 |  {
 42 |     int i, f=0;
 43 |     for(i=0;i<n;i++)
 44 |     {
 45 |       if(a[i]==num)
 46 |       {
 47 |         f=1;break;
 48 |       }
 49 |     }
 50 |     if(f==1)
 51 |     printf("number is found");
 52 |     else
 53 |     printf("number is not found");
 54 |  }
 55 |  
 56 |  void bubble(int a[20],int n)
 57 |  {
 58 |    int i,pass,t;
 59 |    for(pass=1;pass<n;pass++)
 60 |    {
 61 |      for(i=0;i<n-pass;i++)
 62 |      {
 63 |         if(a[i]>a[i+1])
 64 |         {
 65 |           t=a[i];
 66 |           a[i]=a[i+1];
 67 |           a[i+1]=t;
 68 |         }
 69 |      }
 70 |    }
 71 |    printf("bubble sorted numbers::");
 72 |    for(i=0;i<n;i++)
 73 |    printf("%d\t",a[i]);
 74 |  }
 75 |  
 76 | void selection(int a[20],int n)
 77 | {
 78 |    int i,j,t,index,min;
 79 |   for(i=0;i<n;i++)
 80 |   {
 81 |     min=a[i];
 82 |     index=i;
 83 |     
 84 |     for(j=1;j<n;j++)
 85 |     {
 86 |       if(a[j]<min)
 87 |       {
 88 |         min=a[j];
 89 |         index=j;
 90 |       }
 91 |     }
 92 |     t=a[i];
 93 |     a[i]=a[index];
 94 |     a[index]=t;
 95 |  }
 96 |  
 97 |  printf("selection sorted numbers::");
 98 |  for(i=0;i<n;i++)
 99 |  printf("%d\t",a[i]);
100 |  
101 |  
102 |  
103 | } 
104 |  
105 |  
106 |  
107 |  void insertion(int a[20],int n)
108 |  {
109 |    int i,j,num,t;
110 |    for(i=1;i<n;i++)
111 |    {
112 |      num=a[i];
113 |      for(j=i-1;j>=0 && num<a[j];j--)
114 |      {
115 |        t=a[j+1];
116 |        a[j+1]=a[j];
117 |        a[j]=t;
118 |      }
119 |    }
120 |    printf("insertion sorted numbers::");
121 |    for(i=0;i<n;i++)
122 |    printf("%d\t",a[i]);
123 |  }
124 |  
125 |  
126 |  
127 |  
128 |  
129 |  
130 |  
131 |  
132 |  
133 |  
134 |  
135 |  
136 |  
137 |  
138 |  
139 |  
140 |  
141 |  
142 |  
143 |  
144 |  
145 |  
146 |  
147 |  
148 |  
149 |  
150 |  
151 |  
152 |  
153 |  
154 |  
155 |  
156 |  
157 |  
158 |  
159 |  
160 |  
161 | 


--------------------------------------------------------------------------------
/menu_driven_sort1.c:
--------------------------------------------------------------------------------
 1 | // menu driven program of sorting using function
 2 | //1-bubble  2-insertion
 3 | 
 4 | #include<stdio.h>
 5 | int main()
 6 | {
 7 |   int a[20],i,n,ch;
 8 |   void bubble(int a[20],int n);
 9 |   void insertion(int a[20],int n);
10 |   printf("enter limit::");
11 |   scanf("%d",&n);
12 |   printf("enter n numbers::");
13 |   for(i=0;i<n;i++)
14 |   scanf("%d",&a[i]);
15 |   do
16 |   {
17 |    printf("menu=\n1-bubble\n2-insertion\n enter your choice::");
18 |    scanf("%d",&ch);
19 |    switch(ch)
20 |    {
21 |      case 1 : bubble(a,n);
22 |               break;
23 |      case 2 : insertion(a,n);
24 |               break;
25 |      default : printf("invalid choice");
26 |                break;            
27 |    } 
28 |   }while(ch<3);
29 |   
30 | }
31 | 
32 | void bubble(int a[20],int n)
33 | {
34 |   int i,pass,t;
35 |   for(pass=1;pass<n;pass++)
36 |   {
37 |     for(i=0;i<n-pass;i++)
38 |     {
39 |       if(a[i]>a[i+1])
40 |       {
41 |         t=a[i];
42 |         a[i]=a[i+1];
43 |         a[i+1]=t;
44 |       }
45 |     }
46 |   }
47 |   printf("sorted numbers=");
48 |   for(i=0;i<n;i++)
49 |   printf("%d\t",a[i]);
50 | }
51 | 
52 | void insertion(int a[20],int n)
53 | {
54 |   int i,j,num,t;
55 |   for(i=1;i<n;i++)
56 |   {
57 |      num=a[i];
58 |     for(j=i-1;j>=0&&num<a[j];j--)
59 |     {
60 |      t=a[j+1];
61 |      a[j+1]=a[j];
62 |      a[j]=t;
63 |     }
64 |     
65 |   }
66 |   printf("insertion sorted numbers:=");
67 |   for(i=0;i<n;i++)
68 |   printf("%d\t",a[i]);
69 | }
70 | 


--------------------------------------------------------------------------------
/menu_driven_structure.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 |  struct student
 3 |  {
 4 |    char sname[20];
 5 |    int rno;
 6 |    float per;
 7 |  }s1[100];
 8 |  int i,n,num;
 9 |  char nm[20];
10 |  void main()
11 |  {
12 |    void accept();
13 |    void display();
14 |    
15 |    int ch;
16 |    do
17 |    {
18 |      printf("\n1-accept record\n2-display all\n3-search by no.\n4-search by name");
19 |      printf("\n5-maximum per\n5-average per\n enter your choice:");
20 |      scanf("%d",&ch);
21 |      switch(ch)
22 |      {
23 |        case 1 : accept();
24 |                 break;
25 |        case 2 : display();
26 |                 break;
27 |        default : printf("invalid choice!!!!");
28 |     }
29 |      
30 |    }while(ch<3);
31 |    
32 |  }
33 |    void accept()
34 |   {
35 |     printf("enter limit:");
36 |     scanf("%d",&n);
37 |     for(i=0;i<n;i++)
38 |     {
39 |       printf("enter rno name per::");
40 |       scanf("%d%s%f",&s1[i].rno,&s1[i].sname,&s1[i].per);
41 |       
42 |     }
43 |   } 
44 |   
45 |   void display()
46 |   {
47 |      for(i=0;i<n;i++)
48 |      {
49 |     printf("\nrno=%d",s1[i].rno);
50 |     printf("\n name=%s",s1[i].sname);
51 |     printf("\n per=%f",s1[i].per);
52 |     }
53 |   }
54 |   
55 |    
56 |  
57 | 


--------------------------------------------------------------------------------
/node1.c:
--------------------------------------------------------------------------------
 1 | //accept n numbers and display using linked list
 2 | 
 3 | #include<stdio.h>
 4 | #include<stdlib.h>
 5 | #include<malloc.h>
 6 |  struct node
 7 |  {
 8 |    int data;
 9 |    struct node *next;
10 |  };
11 | 
12 | 
13 | struct node * create(struct node *head)
14 | {
15 |    int n,i;
16 |    struct node *newnode,*temp;
17 |    printf("enterlimit::");
18 |    scanf("%d",&n);
19 |    
20 |    for(i=0;i<n;i++)
21 |    {
22 |      newnode=(struct node *) malloc(sizeof(struct node));
23 |      printf("enter values::");
24 |      scanf("%d",&newnode->data);
25 |      newnode->next=NULL;
26 |      
27 |      if(head==NULL)
28 |      {
29 |        head=newnode;
30 |        temp=newnode;
31 |      }
32 |      else
33 |      {
34 |        temp->next=newnode;
35 |        temp=newnode;
36 |      }
37 |    }
38 |    return head;
39 | }
40 | 
41 | void display(struct node *head)
42 | {
43 |   struct node *temp;
44 |   for(temp=head;temp!=NULL;temp=temp->next)
45 |   {
46 |     printf("%d\n",temp->data);
47 |   }
48 | }
49 | 
50 | int main()
51 | {  
52 |   struct node *head=NULL;
53 |   head=create(head);
54 |   
55 |   display(head);
56 | }
57 | 


--------------------------------------------------------------------------------
/node6.c:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<stdlib.h>
  3 | #include<malloc.h>
  4 |  struct node
  5 |  {
  6 |    int data;
  7 |    struct node *next;
  8 |  };
  9 |  
 10 |  struct node * create(struct node *head)
 11 |  {
 12 |    struct node *newnode,*temp;
 13 |    int i,n;
 14 |    printf("enter limit:");
 15 |    scanf("%d",&n);
 16 |    for(i=1;i<=n;i++)
 17 |    {
 18 |      newnode=(struct node *)malloc(sizeof(struct node));
 19 |      printf("enter values:");
 20 |      scanf("%d",&newnode->data);
 21 |      newnode->next=NULL;
 22 |      
 23 |      if(head==NULL)
 24 |      {
 25 |       head=temp=newnode;
 26 |      }
 27 |      else
 28 |      {
 29 |        temp->next=newnode;
 30 |        temp=newnode;
 31 |      }
 32 |    }
 33 |    return head;
 34 |  }
 35 |  
 36 |  void display(struct node *head)
 37 |  {
 38 |    struct node *temp;
 39 |    for(temp=head;temp!=NULL;temp=temp->next)
 40 |    {
 41 |      printf("%d\t",temp->data);
 42 |    }
 43 |  }
 44 |  
 45 |  struct node *insertbeg(struct node *head,int n)
 46 |  {
 47 |    struct node *newnode;
 48 |    newnode=(struct node *)malloc(sizeof(struct node));
 49 |    newnode->data=n;
 50 |    newnode->next=head;
 51 |    head=newnode;
 52 |    return head;
 53 |  }
 54 |  
 55 |  
 56 |  struct node * insertend(struct node *head,int n)
 57 |  {
 58 |    struct node *newnode,*temp;
 59 |    newnode=(struct node *)malloc(sizeof(struct node));
 60 |    newnode->data=n;
 61 |    newnode->next=NULL;
 62 |    for(temp=head;temp->next!=NULL;temp=temp->next);
 63 |    temp->next=newnode;
 64 |    return head;
 65 |  
 66 |  }
 67 |  
 68 |  struct node *insertmid(struct node *head,int n,int pos)
 69 |  {
 70 |    struct node *newnode,*temp;
 71 |    int i;
 72 |    newnode=(struct node *)malloc(sizeof(struct node));
 73 |    newnode->data=n;
 74 |    for(i=1,temp=head;i<pos-1&&temp->next!=NULL;i++,temp=temp->next);
 75 |    newnode->next=temp->next;
 76 |    temp->next=newnode;
 77 |    return head;
 78 |  }
 79 |  
 80 |  struct node *delbeg(struct node *head)
 81 |  {
 82 |    struct node *temp ;
 83 |    temp=head;
 84 |    head=head->next;
 85 |    free(temp);
 86 |    return head;
 87 |  }
 88 |  
 89 |  struct node *delend(struct node *head)
 90 |  {
 91 |    struct node *temp,*temp1;
 92 |    for(temp=head;temp->next->next!=NULL;temp=temp->next);
 93 |    temp1=temp->next;
 94 |    temp->next=NULL;
 95 |    free(temp1);
 96 |    return head;
 97 |  }
 98 |  
 99 |  struct node *delmid(struct node *head,int pos)
100 |  {
101 |    struct node *temp,*temp1;
102 |    int i;
103 |    for(i=1,temp=head;i<pos-1&&temp->next!=NULL;i++,temp=temp->next);
104 |    temp1=temp->next;
105 |    temp->next=temp1->next;
106 |    free(temp1);
107 |    return head;
108 |  }
109 |  
110 |  int main()
111 |  {
112 |    int ch,n,pos;
113 |    struct node *head=NULL;
114 |    
115 |    do
116 |    {
117 |     printf("\nmenu=\n1-create\n2-display\n3-insert beg\n4-insert end\n5insert mid\n6-delbeg\n7-delend\n8-delmid\nenter choice::");
118 |     scanf("%d",&ch);
119 |     switch(ch)
120 |     {
121 |       case 1 : head=create(head);
122 |                break;
123 |       case 2 : display(head);
124 |                 break;
125 |       case 3 : printf("enter number:");
126 |                scanf("%d",&n);
127 |                head=insertbeg(head,n);
128 |                break;
129 |       case 4 : printf("enter number:");
130 |                scanf("%d",&n);
131 |                head=insertend(head,n);
132 |                break;
133 |      case 5 : printf("enter number:");
134 |               scanf("%d",&n);
135 |               printf("enter pos:");
136 |               scanf("%d",&pos);
137 |               head=insertmid(head,n,pos);
138 |               break;
139 |     case 6 : head=delbeg(head);
140 |                break;
141 |     case 7 : head=delend(head);
142 |              break;
143 |      case 8 : printf("enter pos:");
144 |               scanf("%d",&pos);
145 |               head=delmid(head,pos);
146 |               break;
147 |       default : printf("invalid choice ");
148 |       
149 |       
150 |     }
151 |    
152 |    }while(ch< 9);
153 |  }
154 |  
155 |  
156 |  
157 |  
158 |  
159 |  
160 |  
161 |  
162 |  
163 |  
164 |  
165 |  
166 |  
167 |  
168 |  
169 |  
170 |  
171 |  
172 |  
173 |  
174 |  
175 |  
176 |  
177 |  
178 |  
179 |  
180 |  
181 |  
182 |  
183 |  
184 |  
185 | 


--------------------------------------------------------------------------------
/nodee.c:
--------------------------------------------------------------------------------
  1 | //menu driven linked list programme
  2 | 
  3 | #include<stdio.h>
  4 | #include<stdlib.h>
  5 | #include<malloc.h>
  6 | struct node
  7 | {
  8 |   int data;
  9 |   struct node *next;
 10 | };
 11 | 
 12 | struct node * create(struct node *head)
 13 | {
 14 |   struct node *newnode,*temp;
 15 |   int i,n;
 16 |   printf("enter limit::");
 17 |   scanf("%d",&n);
 18 |    for(i=0;i<n;i++)
 19 |    {
 20 |      newnode=(struct node *)malloc(sizeof(struct node));
 21 |      printf("enter values::");
 22 |      scanf("%d",&newnode->data);
 23 |      newnode->next=NULL;
 24 |      
 25 |      if(head==NULL)
 26 |      {
 27 |        head=newnode;
 28 |        temp=newnode;
 29 |      }
 30 |      else
 31 |      {
 32 |        temp->next=newnode;
 33 |        temp=newnode;
 34 |      }
 35 |    }
 36 |    return head;
 37 | }
 38 | 
 39 | void display(struct node *head)
 40 | {
 41 |   struct node *temp;
 42 |   for(temp=head;temp!=NULL;temp=temp->next)
 43 |   printf("%d\t",temp->data);
 44 | }
 45 | 
 46 |  struct node * insertbeg(struct node *head,int num)
 47 |  {
 48 |    struct node *newnode;
 49 |    
 50 |    newnode=(struct node *)malloc(sizeof(struct node));
 51 |    newnode->data=num;
 52 |    
 53 |    newnode->next=head;
 54 |    head=newnode;
 55 |    return head;
 56 |  }
 57 |  
 58 |  struct node * insertend(struct node *head,int num)
 59 |  {
 60 |    struct node *newnode,*temp;
 61 |    
 62 |    newnode=(struct node*)malloc(sizeof(struct node));
 63 |     newnode->data=num;
 64 |     newnode->next=NULL;
 65 |     
 66 |     for(temp=head;temp->next!=NULL;temp=temp->next);
 67 |     temp->next=newnode; 
 68 |    return head;
 69 |  }
 70 | 
 71 | int main()
 72 | {
 73 |   struct node *head=NULL;
 74 |   int ch,num;
 75 |   
 76 |   do
 77 |   {
 78 |      printf("menu=\n1=create\n2=display\n3insertbeg\n4=insert end\n");
 79 |      printf("enter choice::");
 80 |      scanf("%d",&ch);
 81 |      switch(ch)
 82 |      {
 83 |         case 1 : head=create(head);
 84 |                   break;
 85 |                   
 86 |         case 2 : display(head);
 87 |                   break;
 88 |                   
 89 |          case 3 : printf("enter number:");
 90 |                   scanf("%d",&num);
 91 |                   head=insertbeg(head,num);
 92 |                   break;
 93 |                   
 94 |         case 4 : printf("enter number:");
 95 |                 scanf("%d",&num);
 96 |                 head=insertend(head,num);
 97 |                 break;
 98 |                 
 99 |        default : printf("invalide choive::");                   
100 |      }
101 |   }while(ch<5);
102 | }
103 | 


--------------------------------------------------------------------------------
/p.c:
--------------------------------------------------------------------------------
 1 | //accept n nos using sentinal search using function......
 2 | 
 3 | #include<stdio.h>
 4 | 
 5 | 
 6 | void accept(int n)
 7 | {
 8 |   int a[20],i;
 9 |   printf("enter n nos::");
10 |   for(i=0;i<n;i++)
11 |   scanf("%d",&a[i]);
12 | }
13 | 
14 | 
15 | void display(int n)
16 | {
17 |   int a[20],i;
18 |   printf("array element are::");
19 |   for(i=0;i<n;i++)
20 |   printf("%d\t",a[i]);
21 | }
22 | 
23 | 
24 | void check(int n)
25 | {
26 |   int a[20],num,i=0;
27 |   printf("enter number to search::");
28 |   scanf("%d",&num);
29 |   a[n]=num;
30 |   
31 |   while(a[i]!=num)
32 |   {
33 |    i++;
34 |   }
35 |   if(i==n)
36 |   printf("number not found:");
37 |   else
38 |   printf("number found at position=%d",i);
39 | }
40 | int main()
41 | {  int n;
42 |   printf("enter limit::");
43 |   scanf("%d",&n);
44 |   accept(n);
45 |   display(n);
46 |   check(n);
47 | }
48 | 


--------------------------------------------------------------------------------
/palindrome_string.c:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<string.h>
  3 | #define MAX 40
  4 | struct stack
  5 | {
  6 |   char a[MAX];
  7 |   int top;
  8 | }s1;
  9 | 
 10 | void intial()
 11 | {
 12 |   s1.top=-1;
 13 | }
 14 | 
 15 | int isfull()
 16 | {
 17 |   if(s1.top==MAX-1)
 18 |   return 1;
 19 |   else
 20 |   return 0;
 21 | }
 22 | 
 23 | int isempty()
 24 | {
 25 |   if(s1.top=-1)
 26 |   return 1;
 27 |   else
 28 |   return 0;
 29 | }
 30 | 
 31 | void push(char c)
 32 | {
 33 |    if(isfull())
 34 |    printf("stack is full dont push");
 35 |    else
 36 |    {
 37 |      s1.top++;
 38 |      s1.a[s1.top]=c;
 39 |    }
 40 | }
 41 | 
 42 | char pop()
 43 | {
 44 |   char ch;
 45 |   if(isempty())
 46 |   printf("stack is empty dont pop");
 47 |   else
 48 |   {
 49 |     ch=s1.a[s1.top];
 50 |     s1.top--;
 51 |   }
 52 | }
 53 | 
 54 | 
 55 | int main()
 56 | {
 57 |    char s[40];
 58 |    int i;
 59 |    printf("enter string:");
 60 |    gets(s);
 61 |    intial();
 62 |    for(i=0;s[i]!='\0';i++)
 63 |    {
 64 |       push(s[i]);
 65 |    }
 66 |   for(i=0;s[i]!='\0';i++)
 67 |   {
 68 |     if(s[i]!=pop())
 69 |     {
 70 |        break;
 71 |     }
 72 |   }
 73 |   
 74 |   if(isempty())
 75 |   printf("\nstring is palindrome");
 76 |   else
 77 |   printf("\nstring is not palindrome");
 78 | }
 79 | 
 80 | 
 81 | 
 82 | 
 83 | 
 84 | 
 85 | 
 86 | 
 87 | 
 88 | 
 89 | 
 90 | 
 91 | 
 92 | 
 93 | 
 94 | 
 95 | 
 96 | 
 97 | 
 98 | 
 99 | 
100 | 
101 | 
102 | 
103 | 
104 | 
105 | 
106 | 
107 | 
108 | 
109 | 
110 | 
111 | 
112 | 
113 | 


--------------------------------------------------------------------------------
/pointer1.c:
--------------------------------------------------------------------------------
 1 | // read two interger using pointer and perform all arithmatic operation on them
 2 | 
 3 | #include<stdio.h>
 4 | int main()
 5 | {
 6 |    int a,b,*x,*y;
 7 |    printf("enter two numbers::");
 8 |    scanf("%d%d",&a,&b);
 9 |    x=&a;
10 |    y=&b;
11 |    printf("\naddition=%d",*x+*y);
12 |    printf("\nsubstraction=%d",*x-*y);
13 |    printf("\nmultiplication=%d",*x * *y);
14 |    printf("\ndivision=%d",(*x)/(*y));
15 | }
16 | 


--------------------------------------------------------------------------------
/pointer2.c:
--------------------------------------------------------------------------------
 1 | //maximum of two numbers using pointer...
 2 | 
 3 | #include<stdio.h>
 4 | int main()
 5 | {
 6 |   int a,b,*x,*y;
 7 |   printf("enter two numbers::");
 8 |   scanf("%d%d",&a,&b);
 9 |   x=&a;
10 |   y=&b;
11 |   if(*x>*y)
12 |   printf("maximum number=%d",*x);
13 |   else
14 |   printf("maximum number+%d",*y);
15 | }
16 | 


--------------------------------------------------------------------------------
/pointer3.c:
--------------------------------------------------------------------------------
 1 | //even odd using pointer...
 2 | 
 3 | #include<stdio.h>
 4 | int main()
 5 | {
 6 |    int n,*x;
 7 |    printf("enter number::");
 8 |    scanf("%d",&n);
 9 |    x=&n;
10 |    if(*x%2==0)
11 |    printf("number is even ");
12 |    else
13 |    printf("number is odd");
14 | }
15 | 


--------------------------------------------------------------------------------
/pointer4.c:
--------------------------------------------------------------------------------
 1 | //accept number and display cube of it
 2 | 
 3 | #include<stdio.h>
 4 | int main()
 5 | {
 6 |   int n,*x;
 7 |   printf("enter number::");
 8 |   scanf("%d",&n);
 9 |   x=&n;
10 |   printf("cube of number=%d",*x* *x * *x);
11 |  
12 | }
13 | 


--------------------------------------------------------------------------------
/pointer5.c:
--------------------------------------------------------------------------------
 1 | //swapping of two numbers using pointer
 2 | 
 3 | #include<stdio.h>
 4 | int main()
 5 | {
 6 |   int a,b,t,*x,*y;
 7 |   printf("enter two numbers::");
 8 |   scanf("%d%d",&a,&b);
 9 |   x=&a;
10 |   y=&b;
11 |   
12 |   t=*x;
13 |   *x=*y;
14 |   *y=t;
15 |  
16 |   printf("\nswapping number of x=%d",*x);
17 |   printf("\nswapping number of y=%d",*y);
18 | }
19 | 


--------------------------------------------------------------------------------
/pointer7.c:
--------------------------------------------------------------------------------
 1 | //accept number and check prime or not
 2 | 
 3 | #include<stdio.h>
 4 | void main()
 5 | {
 6 |   int n,*pn,s=0,i;
 7 |   printf("enter number::");
 8 |   scanf("%d",&n);
 9 |   pn=&n;
10 |   for(i=2;i<*pn;i++)
11 |   {
12 |      if(*pn%i==0)
13 |      s=s+i;
14 |   }
15 |   if(s==0)
16 |   printf("number is prime");
17 |   else
18 |   printf("number is not prime:");
19 | }
20 | 


--------------------------------------------------------------------------------
/pointer8.c:
--------------------------------------------------------------------------------
 1 | //accept number and check aemstrong or not
 2 | 
 3 | #include<stdio.h>
 4 | int main()
 5 | {
 6 |   int n,*x,d,s=0,n1;
 7 |   printf("enter number::");
 8 |   scanf("%d",&n);
 9 |   x=&n;
10 |   n1=*x;
11 |   while(*x>0)
12 |   {
13 |      d=*x%10;
14 |      *x=*x/10;
15 |      s=s+d*d*d;
16 |   }
17 |   if(s==n1)
18 |   printf("number is armstrong");
19 |   else
20 |   printf("number is not armstrong"); 
21 | }
22 | 


--------------------------------------------------------------------------------
/postfix.c:
--------------------------------------------------------------------------------
  1 | //infix to postfix...
  2 | 
  3 | #include<stdio.h>
  4 | #include<string.h>
  5 | #define max 50
  6 |   struct stack
  7 | {
  8 |   char a[max];
  9 |   int top;
 10 | }s;
 11 | 
 12 | void init()
 13 | {
 14 |   s.top=-1;
 15 | }
 16 | 
 17 | int isfull()
 18 | {
 19 |   if(s.top==max-1)
 20 |   return 1;
 21 |   else
 22 |   return 0;
 23 | }
 24 | 
 25 | int isempty()
 26 | {
 27 |   if(s.top==-1)
 28 |   return 1;
 29 |   else
 30 |   return 0;
 31 | }
 32 | 
 33 | void push(char ch)
 34 | {
 35 |   if(isfull())
 36 |   printf("stack is full dont push");
 37 |   else
 38 |   {
 39 |     s.top++;
 40 |     s.a[s.top]=ch;
 41 |   }
 42 | }
 43 | 
 44 | char pop()
 45 | {
 46 |   char c;
 47 |   if(isempty())
 48 |   return -1;
 49 |   else
 50 |   {
 51 |     c=s.a[s.top];
 52 |     s.top--;
 53 |     return c;
 54 |   }
 55 | }
 56 | 
 57 | 
 58 |  int precedence(char c)
 59 |  {
 60 |    if(c=='(')
 61 |    return 0;
 62 |    if(c=='+' || c=='-')
 63 |    return 1;
 64 |    if(c=='*' || c=='/')
 65 |    return 2;
 66 |    if(c=='$' || c=='^')
 67 |    return 3;
 68 |    return 0;
 69 |  }
 70 |  
 71 |  int main()
 72 |  {
 73 |    char infix[40],postfix[40],ch;
 74 |    int i,j=0;
 75 |    printf("enter string::");
 76 |    scanf("%s",&infix);
 77 |  
 78 |    
 79 |    for(i=0;infix[i]!='\0';i++)
 80 |    {
 81 |      if(infix[i]=='(')
 82 |       infix[i]=')';
 83 |       else if(infix[i]==')')
 84 |       infix[i]='(';
 85 |    }
 86 |    
 87 |    init();
 88 |    
 89 |    for(i=0;infix[i]!='\0';i++)
 90 |    {
 91 |      if(isalpha(infix[i]))
 92 |       postfix[j++]=infix[i];
 93 |      
 94 |      else if(infix[i]=='(' ) 
 95 |       push(infix[i]);
 96 |       
 97 |      else if(infix[i]==')')
 98 |      {
 99 |        while((ch==pop())!='(')
100 |        {
101 |          postfix[j++]=ch;
102 |        }
103 |      }
104 |      else
105 |      {
106 |        while(precedence(s.a[s.top])>=precedence(infix[i]))
107 |        {
108 |          postfix[j++]=pop();
109 |        }
110 |        push(infix[i]);
111 |      }
112 |    
113 |    }
114 |    
115 |    while(!isempty())
116 |    {
117 |      postfix[j++]=pop();
118 |    }
119 |    postfix[j]='\0';
120 |  
121 |    printf("\n postfix string=%s",postfix);
122 |  }
123 | 
124 | 
125 | 
126 | 
127 | 
128 | 
129 | 
130 | 
131 | 
132 | 
133 | 
134 | 
135 | 
136 | 
137 | 
138 | 
139 | 
140 | 
141 | 
142 | 
143 | 
144 | 
145 | 
146 | 
147 | 
148 | 
149 | 
150 | 
151 | 
152 | 
153 | 
154 | 
155 | 
156 | 
157 | 
158 | 
159 | 
160 | 
161 | 
162 | 


--------------------------------------------------------------------------------
/prefix.c:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<string.h>
  3 | #include<ctype.h>
  4 | #define max 50
  5 |   struct stack
  6 | {
  7 |   char a[max];
  8 |   int top;
  9 | }s;
 10 | 
 11 | void init()
 12 | {
 13 |   s.top=-1;
 14 | }
 15 | 
 16 | int isfull()
 17 | {
 18 |   if(s.top==max-1)
 19 |   return 1;
 20 |   else
 21 |   return 0;
 22 | }
 23 | 
 24 | int isempty()
 25 | {
 26 |   if(s.top==-1)
 27 |   return 1;
 28 |   else
 29 |   return 0;
 30 | }
 31 | 
 32 | void push(char ch)
 33 | {
 34 |   if(isfull())
 35 |   printf("stack is full dont push");
 36 |   else
 37 |   {
 38 |     s.top++;
 39 |     s.a[s.top]=ch;
 40 |   }
 41 | }
 42 | 
 43 | char pop()
 44 | {
 45 |   char c;
 46 |   if(isempty())
 47 |   return -1;
 48 |   else
 49 |   {
 50 |     c=s.a[s.top];
 51 |     s.top--;
 52 |     return c;
 53 |   }
 54 | }
 55 | 
 56 | 
 57 |  int precedence(char c)
 58 |  {
 59 |    if(c=='(')
 60 |    return 0;
 61 |    if(c=='+' || c=='-')
 62 |    return 1;
 63 |    if(c=='*' || c=='/')
 64 |    return 2;
 65 |    if(c=='$' || c=='^')
 66 |    return 3;
 67 |    return 0;
 68 |  }
 69 |  
 70 |  void rev(char *ss)
 71 |  {
 72 |     int length=strlen(ss);
 73 |     int i,j;
 74 |     char t;
 75 |     for(i=0,j=length-1;i<j;i++,j--);
 76 |     {
 77 |      t=ss[i];
 78 |      ss[i]=ss[j];
 79 |      ss[j]=t;
 80 |     }
 81 |      
 82 |  }
 83 |  
 84 |  int main()
 85 |  {
 86 |    char infix[40],prefix[40],ch,infix1[40];
 87 |    int i,j=0;
 88 |    printf("enter string::");
 89 |    gets(infix);
 90 |    
 91 |    rev(infix);
 92 |    
 93 |    for(i=0;infix[i]!='\0';i++)
 94 |    {
 95 |      if(infix[i]=='(')
 96 |       infix[i]=')';
 97 |       else if(infix[i]==')')
 98 |       infix[i]='(';
 99 |    }
100 |    
101 |    init();
102 |    
103 |    for(i=0;infix[i]!='\0';i++)
104 |    {
105 |      if(isalpha(infix[i]))
106 |       prefix[j++]=infix[i];
107 |      
108 |      else if(infix[i]=='(' ) 
109 |       push(infix[i]);
110 |       
111 |      else if(infix[i]==')')
112 |      {
113 |        while((ch==pop())!='(')
114 |        {
115 |          prefix[j++]=ch;
116 |        }
117 |      }
118 |      else
119 |      {
120 |        while(precedence(s.a[s.top])>=precedence(infix[i]))
121 |        {
122 |          prefix[j++]=pop();
123 |        }
124 |        push(infix[i]);
125 |      }
126 |    
127 |    }
128 |    
129 |    while(!isempty())
130 |    {
131 |      prefix[j++]=pop();
132 |    }
133 |    prefix[j]='\0';
134 |     
135 |    rev(prefix);
136 |    
137 |    printf("\n prefix string=%s",prefix);
138 |   
139 |  }
140 | 
141 | 
142 | 
143 | 
144 | 
145 | 
146 | 
147 | 
148 | 
149 | 
150 | 
151 | 
152 | 
153 | 
154 | 
155 | 
156 | 
157 | 
158 | 
159 | 
160 | 
161 | 
162 | 
163 | 
164 | 
165 | 
166 | 
167 | 
168 | 
169 | 
170 | 
171 | 
172 | 
173 | 
174 | 
175 | 
176 | 
177 | 
178 | 
179 | 


--------------------------------------------------------------------------------
/probability_search.c:
--------------------------------------------------------------------------------
 1 | //accept n numbers using probability search using function....
 2 | 
 3 | #include<stdio.h>
 4 |  
 5 |   void accept(int n)
 6 |   {
 7 |     int i,a[20];
 8 |     printf("enter n nos::");
 9 |     for(i=0;i<n;i++)
10 |     scanf("%d",&a[i]);
11 |   }
12 |   
13 |   void display(int n)
14 |   {
15 |     int i,a[20];
16 |     printf("array elments are::");
17 |     for(i=0;i<n;i++)
18 |     printf("%d\t",a[i]);
19 |   }
20 |   
21 |   void prob_search(int n)
22 |   {
23 |     int i,a[20],num,t;
24 |     printf("enter key::");
25 |     scanf("%d",&num);
26 |     
27 |     for(i=0;i<n;i++)
28 |     {
29 |       if(a[i]==num)
30 |       {
31 |         if(i!=0)
32 |         {
33 |           t=a[i-1];
34 |           a[i-1]=a[i];
35 |           a[i]=t;
36 |         }
37 |       }
38 |     }
39 |     printf("elements are::");
40 |     for(i=0;i<n;i++)
41 |     printf("%d\t",a[i]);
42 |   }
43 | 
44 | int main()
45 | {
46 |   int n;
47 |   printf("enter limit::");
48 |   scanf("%d",&n);
49 |   accept(n);
50 |   display(n);
51 |   prob_search(n);
52 | }
53 | 


--------------------------------------------------------------------------------
/process.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #define y 2
 3 | void main()
 4 | {
 5 |   int x;
 6 |  x=y*10;
 7 |  printf("%d\n",x);
 8 |  #undef y
 9 |  #define y 4
10 |  x=y*4;
11 |  printf("%d\n",x); 
12 | }
13 | 


--------------------------------------------------------------------------------
/quick_sort.c:
--------------------------------------------------------------------------------
 1 | //accept n numbers in array and sort them using quick sort recursively....
 2 | 
 3 | #include<stdio.h>
 4 | 
 5 | int partition(int a[],int lb,int ub)
 6 | {
 7 |   int j,t;
 8 |   int pivote=a[ub];
 9 |   int i=(lb-1);
10 |   for(j=lb;j<=ub-1;j++)
11 |   {
12 |     if(a[j]<=pivote)
13 |     {
14 |      i++;
15 |      t=a[i];
16 |      a[i]=a[j];
17 |      a[j]=t;
18 |     }
19 |   }
20 |    t=a[i+1];
21 |    a[i+1]=a[ub];
22 |    a[ub]=t;
23 |    return(i+1);
24 | }
25 | 
26 | 
27 | void qsort(int a[],int lb,int ub)
28 | {
29 |   if(lb<ub)
30 |   {
31 |     int j;
32 |     j=partition(a,lb,ub);
33 |     qsort(a,lb,j-1);
34 |     qsort(a,j+1,ub);
35 |   }
36 | }
37 | 
38 | void main()
39 | {
40 |   int a[30],i,n;
41 |   printf("enter limit::");
42 |   scanf("%d",&n);
43 |   printf("enter n nos in array::");
44 |   for(i=0;i<n;i++)
45 |   scanf("%d",&a[i]);
46 |   
47 |   qsort(a,0,n-1);
48 |   
49 |   printf("sorted array elements are::\n");
50 |   for(i=0;i<n;i++)
51 |   printf("%d\t",a[i]);
52 | }
53 | 


--------------------------------------------------------------------------------
/random_number.c:
--------------------------------------------------------------------------------
 1 | //accept n number randomly and return its position if number is found using function(used rand() function)...
 2 | 
 3 | #include<stdio.h>
 4 | #include<math.h>
 5 | #include<stdlib.h>
 6 | 
 7 | int search(int a[30],int num,int n)
 8 | {
 9 |   int i;
10 |   for(i=0;i<n;i++)
11 |   {
12 |     if(a[i]==num)
13 |     return i;
14 |   }
15 |   return i;
16 | }
17 | 
18 | 
19 | 
20 | int main()
21 | {
22 |   int a[30],i,n,num;
23 |   printf("enter limit::");
24 |   scanf("%d",&n);
25 |   for(i=0;i<n;i++)
26 |   a[i]=rand()%1000;
27 |   
28 |   printf("random numbers::");
29 |   for(i=0;i<n;i++)
30 |   printf("%d\t",a[i]);
31 |   
32 |   print("enter number to search::");
33 |   scanf("%d",&num);
34 |   
35 |   if(search(a,num,n)==n)
36 |    printf("number not found::");
37 |    else
38 |    printf("number is found");
39 |    }
40 |   
41 | 


--------------------------------------------------------------------------------
/rev.c:
--------------------------------------------------------------------------------
 1 | Que:reverse stack string.
 2 | 
 3 | #include<stdio.h>
 4 | #include<string.h>
 5 | #define MAC 50
 6 |  struct stack
 7 |  {
 8 |    char a[MAC];
 9 |    int top;
10 |  }s;
11 |  
12 |  void initial()
13 |  {
14 |    s.top=-1;
15 |  }
16 |  
17 |  int isfull()
18 |  {
19 |    if(s.top==MAC-1)
20 |    return 1;
21 |    else
22 |    return 0;
23 |  }
24 |  
25 |  void push(char c)
26 |  {
27 |    if(isfull())
28 |    printf("stack is full");
29 |    else
30 |    {
31 |      s.top++;
32 |      s.a[s.top]=c;
33 |    }
34 |  }
35 |  
36 |  void display()
37 |  {
38 |    int i;
39 |    for(i=s.top;i>=0;i--)
40 |    printf("%c",s.a[i]);
41 |  }
42 |  
43 |  int main()
44 |  {
45 |    char s1[40];
46 |    int i;
47 |    printf("enter string::");
48 |    gets(s1);
49 |    initial();
50 |    
51 |    for(i=0;s1[i]!='\0';i++)
52 |    {
53 |      if(s1[i]==' ')
54 |      {
55 |         display();
56 |         initial();
57 |      }
58 |      else
59 |      {
60 |        push(s1[i]);
61 |      }
62 |    
63 |    }
64 |    display();
65 |  }
66 | 


--------------------------------------------------------------------------------
/san.c:
--------------------------------------------------------------------------------
 1 | //read file number.txt and check number is found in that file or not....
 2 | 
 3 | #include<stdio.h>
 4 | #include<stdlib.h>
 5 | int main()
 6 | {
 7 | 	FILE *fp1;
 8 | 	int num,flag=0,x,a[100],i=0,n,top,mid,bottom;
 9 | 	fp1=fopen("number.txt","r");
10 | 	if(fp1==NULL)
11 | 	{
12 | 	printf("not found");
13 | 	exit(0);
14 | 	}
15 | while(!feof(fp1))
16 | {
17 | 	fscanf(fp1,"%d",&num);
18 | 	a[i++]=num;
19 | }
20 | n=i;
21 | printf("enter number to search=");
22 | scanf("%d",&x);
23 | top=0;
24 | bottom=n-1;
25 | while(top<=bottom)
26 | {
27 | 	mid=top+bottom/2;
28 | 	if(x==a[mid])
29 | 	{
30 | 		flag=1;
31 | 		break;
32 | 	}
33 | 	if(x>a[mid])
34 | 	top=mid+1;
35 | 	else
36 | 	bottom=mid-1;
37 | }
38 | if(flag==1)
39 | printf("found");
40 | else
41 | printf("not found");
42 | fclose(fp1);
43 | }
44 | 


--------------------------------------------------------------------------------
/selection_sort1.c:
--------------------------------------------------------------------------------
 1 | //accept n nos and arrage them using selection sort....
 2 | 
 3 | #include<stdio.h>
 4 | int main()
 5 | {
 6 |   int n,i,a[50],j,t,index,min;
 7 |   printf("enter limit::");
 8 |   scanf("%d",&n);
 9 |   printf("enter n nos::");
10 |   for(i=0;i<n;i++)
11 |   scanf("%d",&a[i]);
12 |   
13 |   for(i=0;i<n;i++)
14 |   {
15 |      min=a[i];
16 |      index=i;
17 |      for(j=i;j<n;j++)
18 |      {
19 |         if(a[j]<min)
20 |         {
21 |            min=a[j];
22 |            index=j;
23 |         }
24 |      }
25 |      if(i!=index)
26 |      {
27 |         t=a[i];
28 |         a[i]=a[index];
29 |         a[index]=t;
30 |      }
31 |   
32 |   }
33 |   printf("sorted nos are::\n");
34 |   for(i=0;i<n;i++)
35 |   printf("%d\t",a[i]);
36 | }
37 | 


--------------------------------------------------------------------------------
/selection_sort2.c:
--------------------------------------------------------------------------------
 1 | //accept n student names from user and display ascending order using selection sort...
 2 | #include<string.h>
 3 | #include<stdio.h>
 4 | int main()
 5 | {
 6 |   int i,j,n,index;
 7 |   char name[20][20],t[20],min[30];
 8 |   printf("enter limit::");
 9 |   scanf("%d",&n);
10 |   printf("enter n students names::");
11 |   for(i=0;i<n;i++)
12 |   scanf("%s",&name[i]);
13 |   
14 |   for(i=0;i<n;i++)
15 |   {
16 |      strcpy(min,name[i]);
17 |      index=i;
18 |      for(j=i;j<n;j++)
19 |      {
20 |         if(strcmp(name[j],min)<0)
21 |         {
22 |           strcpy(min,name[j]);
23 |           index=j;
24 |         }
25 |      }
26 |      strcpy(t,name[i]);
27 |      strcpy(name[i],name[index]);
28 |      strcpy(name[index],t);
29 |      
30 |   }
31 |   printf("sorted names::\n");
32 |   for(i=0;i<n;i++)
33 |   printf("%s\t",name[i]);
34 | 
35 | }
36 | 


--------------------------------------------------------------------------------
/selection_sort3.c:
--------------------------------------------------------------------------------
 1 | // create structure emp(eno,ename,sal) and sort them by emp salary using selection sort...
 2 | 
 3 | #include<stdio.h>
 4 |   struct emp
 5 |   {
 6 |     int eno;
 7 |     char name[20];
 8 |     float sal;
 9 |   }e1[50],t;
10 |   
11 |   int main()
12 |   {
13 |      int i,n,j,index,min;
14 |      printf("enter limit::");
15 |      scanf("%d",&n);
16 |      for(i=0;i<n;i++)
17 |      {
18 |        printf("enter emp no name sal::");
19 |        scanf("%d%s%f",&e1[i].eno,e1[i].name,&e1[i].sal);
20 |      }
21 |      
22 |      for(i=0;i<n;i++)
23 |      {
24 |         min=e1[i].sal;
25 |         index=i;
26 |         for(j=i;j<n;j++)
27 |         {
28 |           if(e1[j].sal<min)
29 |           {
30 |              min=e1[j].sal;
31 |              index=j;
32 |           }     
33 |        }
34 |        t=e1[i];
35 |        e1[i]=e1[index];
36 |        e1[index]=t;
37 |        
38 |      }
39 |      printf("sorted emp by sal::\n");
40 |      for(i=0;i<n;i++)
41 |      printf("%d\t%s\t%f\n",e1[i].eno,e1[i].name,e1[i].sal);
42 |   }
43 | 


--------------------------------------------------------------------------------
/selection_sort4.c:
--------------------------------------------------------------------------------
 1 | // create structure emp(eno,ename,sal) and sort them by emp number using selection sort...
 2 | 
 3 | #include<stdio.h>
 4 |   struct emp
 5 |   {
 6 |     int eno;
 7 |     char name[20];
 8 |     float sal;
 9 |   }e1[50],t;
10 |   
11 |   int main()
12 |   {
13 |      int i,n,j,index,min;
14 |      printf("enter limit::");
15 |      scanf("%d",&n);
16 |      for(i=0;i<n;i++)
17 |      {
18 |        printf("enter emp no name sal::");
19 |        scanf("%d%s%f",&e1[i].eno,e1[i].name,&e1[i].sal);
20 |      }
21 |      
22 |      for(i=0;i<n;i++)
23 |      {
24 |         min=e1[i].eno;
25 |         index=i;
26 |         for(j=i;j<n;j++)
27 |         {
28 |           if(e1[j].eno<min)
29 |           {
30 |              min=e1[j].sal;
31 |              index=j;
32 |           }     
33 |        }
34 |        t=e1[i];
35 |        e1[i]=e1[index];
36 |        e1[index]=t;
37 |        
38 |      }
39 |      printf("sorted emp by emp no::\n");
40 |      for(i=0;i<n;i++)
41 |      printf("%d\t%s\t%f\n",e1[i].eno,e1[i].name,e1[i].sal);
42 |   }
43 | 


--------------------------------------------------------------------------------
/sen.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | 
 3 | void accept(int a[],int n)
 4 | {
 5 |   int i;
 6 |   printf("enter array element::");
 7 |   for(i=0;i<n;i++)
 8 |   scanf("%d",&a[i]);
 9 | }
10 | 
11 | void disp(int a[],int n)
12 | {
13 |   int i;
14 |   printf("array elements are::");
15 |   for(i=0;i<n;i++)
16 |   printf("%d\t",a[i]);
17 | }
18 | 
19 |  void sentinal(int a[],int n)
20 |  {
21 |    int i=0,num;
22 |    printf("enter number to search::");
23 |    scanf("%d",&num);
24 |    a[n]=num;
25 |    while(a[i]!=num)
26 |    {
27 |     i++;
28 |    }
29 |   if(i==n)
30 |   printf("number not found");
31 |   else
32 |   printf("number found at position=%d",i);
33 |  }
34 | 
35 | void main()
36 | {
37 |   int i,a[30],n,ans,num;
38 |   printf("enter limit::");
39 |   scanf("%d",&n);
40 |   
41 |   accept(a,n);
42 |   disp(a,n);
43 |   sentinal(a,n);
44 |  
45 | }
46 | 


--------------------------------------------------------------------------------
/singly-linkedlist:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<stdlib.h>
  3 | 
  4 |  struct node
  5 |  {
  6 |    int data;
  7 |    struct node *next;
  8 |  };
  9 | struct node* create(struct node *list)
 10 | {    int i,n;
 11 | 	struct node *newnode,*temp;
 12 | 	printf("enter limit::");
 13 | 	scanf("%d",&n);
 14 | 	
 15 | 	for(i=0;i<n;i++)
 16 | 	
 17 |    {
 18 | 	newnode=(struct node*)malloc(sizeof(struct node));
 19 | 	printf("enter value::");
 20 | 	scanf("%d",&newnode->data);
 21 | 	//newnode->next=NULL;
 22 | 	if(list==NULL)
 23 | 	{
 24 | 	  list=newnode;
 25 | 	  temp=newnode;
 26 | 	  newnode->next=list;
 27 | 	}
 28 | 	else
 29 | 	{
 30 | 	  temp->next=newnode;
 31 | 	  newnode->next=list;
 32 | 	  temp=newnode;	
 33 | 	}
 34 |   }
 35 | 	return list;
 36 | }
 37 | 
 38 | void display(struct node *list)
 39 | {
 40 |    struct node *temp=list;
 41 |    do
 42 |    {
 43 |       printf("%d\t",temp->data);
 44 |       temp=temp->next;
 45 |    }while(temp!=list);
 46 | }
 47 | 
 48 | struct node *insertbeg(struct node *list,int n)
 49 | {
 50 | 	struct node *newnode,*temp;
 51 | 	
 52 | 	newnode=(struct node*)malloc(sizeof(struct node));
 53 | 	newnode->data=n;
 54 | 	for(temp=list;temp->next!=list;temp=temp->next);
 55 | 	newnode->next=list;
 56 | 	list=newnode;
 57 | 	temp->next=list;
 58 | 	return list;
 59 | }
 60 | 
 61 | struct node *insertend(struct node *list,int n)
 62 | {
 63 | 	struct node *newnode,*temp;
 64 | 	
 65 | 	newnode=(struct node*)malloc(sizeof(struct node));
 66 | 	newnode->data=n;
 67 | 	newnode->next=NULL;
 68 | 	for(temp=list;temp->next!=NULL;temp=temp->next);
 69 | 	temp->next=newnode;
 70 | 	return list;
 71 | }
 72 | 
 73 | struct node *insertmid(struct node *list,int n,int p)
 74 | {    int i;
 75 | 	struct node *newnode,*temp;
 76 | 	
 77 | 	newnode=(struct node*)malloc(sizeof(struct node));
 78 | 	newnode->data=n;
 79 | 	for(i=1,temp=list;(i<p-1 && temp->next!=NULL);i++,temp=temp->next);
 80 | 	newnode->next=temp->next;
 81 | 	temp->next=newnode;
 82 | 	return list;
 83 | }
 84 | 
 85 | int main()
 86 | {    int n,ch,p;
 87 | 
 88 | 
 89 | 	 struct node *list=NULL;
 90 | 	 do
 91 | 	 {
 92 | 	 printf("\n1=create\n2=display\n3=insert begin\n4=insert end\n5=insertmid\nenter your choice::");
 93 | 	 scanf("%d",&ch);
 94 | 	 switch(ch)
 95 | 	 {
 96 | 
 97 | 	  case 1 : list=create(list); break;
 98 | 	  case 2 : display(list); break;
 99 | 	  case 3 :printf("enter number::");
100 | 	          scanf("%d",&n);
101 | 			  list=insertbeg(list,n);
102 | 			  break;
103 | 	 case 4 :printf("enter number::");
104 | 	          scanf("%d",&n);
105 | 	         list=insertend(list,n);
106 | 	         break;
107 | 	 case 5 :printf("enter number::");
108 | 	         scanf("%d",&n);
109 | 	         printf("enter position::");
110 | 	         scanf("%d",&p);
111 | 	         list=insertmid(list,n,p);
112 | 	         break;
113 |      }
114 |    }while(ch<6);
115 | }
116 | 
117 | 
118 | 


--------------------------------------------------------------------------------
/slip17_que1.cpp:
--------------------------------------------------------------------------------
 1 | //Q1 Implement a list library (singlylist.h) for a singly linked list. Create a linked list, 
 2 | //reverse it and display reversed linked list. 
 3 | 
 4 | #include<stdio.h>
 5 | #include<stdlib.h>
 6 | #include<malloc.h>
 7 | #define memory (node*)malloc(sizeof(node))
 8 |  typedef struct node
 9 | {
10 |   int data;
11 |   struct node *next;
12 | }node;
13 | 
14 | node *create(node *list)
15 | {
16 |   node *newnode,*temp;
17 |   int n,i;
18 |  printf("enter limit::");
19 |  scanf("%d",&n);
20 |  for(i=0;i<n;i++)
21 |  {
22 |    newnode=memory;
23 |   printf("enter value::");
24 |   scanf("%d",&newnode->data);
25 |   newnode->next=NULL;
26 |   if(list==NULL)
27 |   list=temp=newnode;
28 |   else
29 |   {
30 |     temp->next=newnode;
31 |     temp=newnode;
32 |   }
33 |  }
34 |  return list;
35 | }
36 | 
37 |  void disp(node *list)
38 | {
39 |   node *temp;
40 |  printf("\n linked list=\n");
41 |  for(temp=list;temp!=NULL;temp=temp->next)
42 |   printf("%d\t",temp->data);
43 | }
44 | 
45 | 
46 | node *reverse(node *list)
47 | { node *temp,*ne,*prev;
48 |    temp=list;
49 |    prev=NULL;
50 |   while(temp!=NULL)
51 |   {
52 |     ne=temp->next;
53 |     temp->next=prev;
54 |     prev=temp;
55 |     temp=ne;
56 |   }
57 |   list=prev;
58 |     disp(list);
59 | }
60 |  
61 | int main()
62 | {
63 |   node *list=NULL;
64 |   list=create(list); 
65 |   list=reverse(list);
66 | }
67 | 


--------------------------------------------------------------------------------
/sort.names.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | void selection(char a[20][20],int n)
 4 |  { int i,j,index;
 5 |    char min[20],t[20];
 6 |   for(i=0;i<n;i++)
 7 |   {
 8 |      strcpy(min,a[i]);
 9 |      index=i;
10 |      for(j=i+1;j<n;j++)
11 |      {
12 |        if(strcmp(min,a[j])<0)
13 |        {
14 |          strcpy(min,a[j]);
15 |          index=j;
16 |        }
17 |      }
18 |     
19 |      
20 |        strcpy(t,a[i]);
21 |        strcpy(a[i],a[index]);
22 |       strcpy(a[index],t);
23 |      
24 |   }
25 | 
26 | }
27 | 
28 | int main()
29 | {
30 |   char a[100][100];
31 |   int i,n,index,ans;
32 |   printf("enter limit:");
33 |   scanf("%d",&n);
34 |   printf("enter n nos::");
35 |   for(i=0;i<n;i++)
36 |   scanf("%s",&a[i]);
37 |   
38 |   selection(a,n);
39 |      printf("sorted names::");
40 |   for(i=0;i<n;i++)
41 |   printf("%s\t",a[i]);
42 |  
43 |   }
44 | 


--------------------------------------------------------------------------------
/sort_using_function1.c:
--------------------------------------------------------------------------------
 1 | // selection_sort using function...
 2 | 
 3 | #include<stdio.h>
 4 | int main()
 5 | {
 6 |   int a[30],i,n;
 7 |   void insertion(int a[30],int n);
 8 |   printf("enter limit::");
 9 |   scanf("%d",&n);
10 |   printf("enter n numbers::");
11 |   for(i=0;i<n;i++)
12 |   scanf("%d",&a[i]);
13 |   
14 |   insertion(a,n);
15 | }
16 | 
17 | void insertion(int a[30],int n)
18 | {
19 |   int i,j,t,num;
20 |   for(i=1;i<n;i++)
21 |   {
22 |     num=a[i];
23 |     for(j=i-1;j>=0 && num<a[j];j--)
24 |     {
25 |        t=a[j+1];
26 |        a[j+1]=a[j];
27 |        a[j]=t;
28 |     }
29 |   }
30 |   printf("sorted numbers::");
31 |   for(i=0;i<n;i++)
32 |   printf("%d\t",a[i]);
33 | }
34 | 


--------------------------------------------------------------------------------
/ss.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | 
 3 | void selection(int a[100],int n)
 4 |  { int i,j,min,index,t;
 5 |   
 6 |   for(i=0;i<n;i++)
 7 |   {
 8 |      min=a[i];
 9 |      index=i;
10 |      for(j=i;j<n;j++)
11 |      {
12 |        if(a[j]<min)
13 |        {
14 |          min=a[j];
15 |          index=j;
16 |        }
17 |      }
18 |      if(j=index)
19 |      {
20 |        t=a[i];
21 |        a[i]=a[index];
22 |        a[index]=t;
23 |      }
24 |   }
25 |  
26 | }
27 | 
28 | int main()
29 | {
30 |   int a[100],i,j,min,t,n,index;
31 |   printf("enter limit:");
32 |   scanf("%d",&n);
33 |   printf("enter n nos::");
34 |   for(i=0;i<n;i++)
35 |   scanf("%d",&a[i]);
36 |   
37 |   selection(a,n);
38 |    printf("sorted names::");
39 |   for(i=0;i<n;i++)
40 |   printf("%d\t",a[i]);
41 |   }
42 | 


--------------------------------------------------------------------------------
/ss1.c:
--------------------------------------------------------------------------------
 1 | //accept n number and print ascending order using selection sort using function....
 2 | 
 3 | #include<stdio.h>
 4 | 
 5 | int selection(int a[100],int n)
 6 |  { int i,j,min,index,t;
 7 |   
 8 |   for(i=0;i<n;i++)
 9 |   {
10 |      min=a[i];
11 |      index=i;
12 |      for(j=i;j<n;j++)
13 |      {
14 |        if(a[j]<min)
15 |        {
16 |          min=a[j];
17 |          index=j;
18 |        }
19 |      }
20 |      if(j=index)
21 |      {
22 |        t=a[i];
23 |        a[i]=a[index];
24 |        a[index]=t;
25 |      }
26 |   }
27 |   printf("sorted names::");
28 |   for(i=0;i<n;i++)
29 |   printf("%d\t",a[i]);
30 |  
31 | }
32 | 
33 | int main()
34 | {
35 |   int a[100],i,j,min,t,n,index,ans;
36 |   printf("enter limit:");
37 |   scanf("%d",&n);
38 |   printf("enter n nos::");
39 |   for(i=0;i<n;i++)
40 |   scanf("%d",&a[i]);
41 |   
42 |   ans=selection(a,n);
43 |    
44 |   }
45 | 


--------------------------------------------------------------------------------
/stack1.c:
--------------------------------------------------------------------------------
  1 | 
  2 | #include<stdio.h>
  3 | 
  4 | # define MAX 6
  5 |  struct stack
  6 |  {
  7 |    int a[MAX];
  8 |    int top;
  9 | }s;
 10 | 
 11 | void inital()
 12 | {
 13 |   s.top=-1;
 14 | } 
 15 | 
 16 | int isempty()
 17 | {
 18 |   if(s.top==-1)
 19 |   return 1;
 20 |   else
 21 |   return 0;
 22 | }
 23 | 
 24 | int isfull()
 25 | {
 26 |   if(s.top==MAX-1)
 27 |   return 1;
 28 |   else
 29 |   return 0;
 30 | }
 31 | 
 32 | void push(int n)
 33 | {
 34 |    if(isfull())
 35 |    printf("stack is full dont push🔝️");
 36 |    else
 37 |    {
 38 |      s.top++;
 39 |      s.a[s.top]=n;
 40 |      printf("\npush successfull🎉️");
 41 |    }
 42 | }
 43 | 
 44 | void pop()
 45 | {
 46 |   int value;
 47 |   if(isempty())
 48 |    printf("stack is empty dont pop⬇️");
 49 |    else
 50 |    {
 51 |      value=s.a[s.top];
 52 |      s.top--;
 53 |      printf("\npoped value=%d",value);
 54 |    }
 55 | }
 56 | 
 57 | 
 58 | void disp()
 59 | {  int i;
 60 |   for(i=s.top;i>=0;i--)
 61 |   {
 62 |     printf("%d\n",s.a[i]);
 63 |   }
 64 | }
 65 | 
 66 | int main()
 67 | {
 68 |    int ch,n;
 69 |    inital();
 70 |    do
 71 |    {
 72 |     printf("\n1-push\n2-pop\n3-display\nchoose your choice::");
 73 |     scanf("%d",&ch);
 74 |     switch(ch)
 75 |     {
 76 |       case 1 :printf("enter number::");
 77 |               scanf("%d",&n);
 78 |               push(n);
 79 |               break;
 80 |       case 2 : pop();
 81 |                break;
 82 |       case 3 : disp();
 83 |                break;
 84 |       default : printf("invalid choice✖️");
 85 |     }
 86 |     
 87 |     
 88 |    }while(ch<4);
 89 |    
 90 |    
 91 |    
 92 | }
 93 | 
 94 | 
 95 | 
 96 | 
 97 | 
 98 | 
 99 | 
100 | 
101 | 
102 | 
103 | 
104 | 
105 | 
106 | 
107 | 
108 | 
109 | 
110 | 
111 | 


--------------------------------------------------------------------------------
/string_stack.c:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<string.h>
  3 | # define MAX 20
  4 | struct stack
  5 | {
  6 |   char a[20][20];
  7 |   int top;
  8 | }s1;
  9 | 
 10 | void initial()
 11 | {
 12 |   s1.top=-1;
 13 | }
 14 | 
 15 | char isempty()
 16 | {
 17 |   if(s1.top==-1)
 18 |   return 1;
 19 |   else
 20 |   return 0;
 21 | }
 22 | 
 23 | char isfull()
 24 | {
 25 |   if(s1.top==MAX-1)
 26 |   return 1;
 27 |   else
 28 |   return 0;
 29 | }
 30 | 
 31 | void push(char nm[20])
 32 | {
 33 |   if(isfull())
 34 |   printf("stack is full dont push");
 35 |   else
 36 |   {
 37 |     s1.top++;
 38 |     strcpy(s1.a[s1.top],nm);
 39 |     printf("push succeed");
 40 |   }
 41 | }
 42 | 
 43 | void pop()
 44 | {
 45 |   char nm[20];
 46 |   if(isempty())
 47 |   printf("stack is empty dont pop:");
 48 |   else
 49 |   {
 50 |     strcpy(nm,s1.a[s1.top]);
 51 |     s1.top--;
 52 |     printf("\n poped value=%s",nm);
 53 |   }
 54 | }
 55 | 
 56 | 
 57 | void disp()
 58 | {
 59 |   int i;
 60 |   for(i=s1.top;i>=0;i--)
 61 |   printf("%s\n",s1.a[i]);
 62 | }
 63 | 
 64 | int main()
 65 | {
 66 |   int ch;
 67 |   char nm[20];
 68 |   initial();
 69 |   do
 70 |   {
 71 |     printf("\n1-push\n2-pop\n3=display\nenter choice::");
 72 |     scanf("%d",&ch);
 73 |     switch(ch)
 74 |     {
 75 |       case 1 : printf("enter name");
 76 |               scanf("%s",&nm);
 77 |               push(nm);
 78 |               break;
 79 |       case 2 : pop();break;
 80 |       
 81 |       case 3 : disp();
 82 |                 break;
 83 |       default : printf("invalid choice");
 84 |     }
 85 |   }while(ch<4);
 86 | }
 87 | 
 88 | 
 89 | 
 90 | 
 91 | 
 92 | 
 93 | 
 94 | 
 95 | 
 96 | 
 97 | 
 98 | 
 99 | 
100 | 
101 | 
102 | 
103 | 
104 | 
105 | 
106 | 
107 | 
108 | 
109 | 
110 | 
111 | 
112 | 
113 | 
114 | 


--------------------------------------------------------------------------------
/string_stack1.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | #define MAX 20
 4 | struct stack
 5 | {
 6 |   char m[MAX];
 7 |   int top;
 8 | }s1;
 9 | 
10 | void initial()
11 | {
12 |  s1.top=-1;
13 | }
14 | 
15 | int isfull()
16 | {
17 |   if(s1.top==MAX-1)
18 |   return 1;
19 |   else
20 |   return 0;
21 | }
22 | 
23 | int push(char c)
24 | {
25 |   if(isfull())
26 |   printf("stack is full dont push...");
27 |   else
28 |   {
29 |      s1.top++;
30 |      s1.m[s1.top]=c;
31 |   }
32 | }
33 | 
34 | void display()
35 | {
36 |   int i;
37 |   for(i=s1.top;i>=0;i--)
38 |   printf("%c",s1.m[i]);
39 | }
40 | 
41 | int main()
42 | {
43 |   char s[50];
44 |   int i;
45 |   printf("enter string::");
46 |   scanf("%s",&s);
47 |   initial();
48 |   for(i=0;s[i]!='\0';i++)
49 |   {
50 |     push(s[i]);
51 |   }
52 |   display();
53 | }
54 | 


--------------------------------------------------------------------------------