1.

Array Search
# include <stdio.h>
# include <stdlib.h>
# define SIZE 100
int a[SIZE], i, n, e;
int linearSearch()
{
for (i = 0; i < n; i++)
if (e == a[i])
return i;
return -1;
}
int sort()
{
int i = 0, j, temp;
for (; i < n - 1; i++)
for (j = i + 1; j < n; j++)
if(a[i] > a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
int binarySearch()
{
sort();
int low = 0, high = n - 1, mid;
while(low <= high)
{
mid = (low + high) / 2;
if (e == a[mid])
return mid;
if(e < a[mid])
high = mid - 1;
else
low = mid + 1;
}
return -1;
}
int main()
{
int i = 0, c, r;
printf("Enter size of array (1 - 100): ");
scanf("%d", &n);
for(; i < n; i++)
{
printf("Enter element %d: ", (i + 1));
scanf("%d", (a + i));
}
while(1)
{
printf("Enter element to be searched: ");
scanf("%d", &e);
printf("MENU:\n1. Linear Search\n2. Binary Search\nOthers: Exit\n");
printf("Enter your choice: ");
scanf("%d", &c);
switch (c)
{
 case 1: r = linearSearch();
break;
case 2: r = binarySearch();
break;
default: exit(0);
}
if (r == -1)
printf("Element not found!\n");
else
printf("Element found at index %d!\n", r);
}
return 0;
}

2. Array Sort Ascending

# include <stdio.h>
# include <stdlib.h>
# define SIZE 100
int a[SIZE], i, n;
void swap(int *a, int *b)
{
int t = *a;
*a = *b;
*b = t;
}
int selectionSort()
{
int i = 0, j, temp;
for (; i < n - 1; i++)
for (j = i + 1; j < n; j++)
if(a[i] > a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
void bubbleSortUnoptimised()
{
int i = 0, j, temp;
for (; i < n - 1; i++)
{
for (j = 0; j < n - i - 1; j++)
if(a[i] > a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
void bubbleSort()
{
int i = 0, j, temp, flag = 1;
for (; i < n - 1 && flag; i++)
{
flag = 0;
for (j = 0; j < n - i - 1; j++)
if(a[i] > a[j])
 {
flag = 1;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
void insertionSort()
{
int i = 1, j;
for (; i < n; i++)
{
for (j = i - 1; j >= 0 && a[i] < a[j]; j--)
a[j + 1] = a[j];
a[j + 1] = a[i];
}
}
void shellSort()
{
int i, j, gap = n / 2;
for (; gap > 0; gap /= 2)
{
for (i = gap; i < n; i++)
{
for (j = i - gap; j >= 0 && a[i] < a[j]; j -= gap)
a[j + gap] = a[j];
a[j + gap] = a[i];
}
}
}
void merge(int l, int m, int r)
{
int i = l, j = m + 1, k = l, *temp;
temp = (int *)(malloc((r - l + 1) * sizeof(int)));
while (i <= m && j <= r)
{
if (a[i] <= a[j])
temp[k++] = a[i++];
else
temp[k++] = a[j++];
}
while (i <= m)
temp[k++] = a[i++];
while (j <= r)
temp[k++] = a[j++];
for (i = l; i <= r; i++)
a[i] = temp[i - l];
}
void mergeSortRec(int l, int r)
{
if (l < r)
{
int m = (l + r) / 2;
mergeSortRec(l, m);
mergeSortRec(m + 1, r);
merge(l, m, r);
}
}
int partition(int l, int h)
{
int pivot = a[h], i = l - 1;
for (int j = l; j < h; j++)
{
if (a[j] <= pivot)
{
i++;
swap(&a[i], &a[j]);
}
}
swap(&a[i + 1], &a[h]);
return i + 1;
}
int partition2(int l, int h)
{
int p = l;
while(l <= h)
{
while (l <= h && a[l] <= a[p])
l++;
while (l <= h && a[h] > a[p])
h--;
if (l <= h)
swap(&a[l], &a[h]);
}
swap(&a[p],&a[h]);
return h;
}
void quickSortRec(int l, int h)
{
if(l < h)
{
int p = partition(l, h);
quickSortRec(l, p - 1);
quickSortRec(p + 1, h);
}
}
void quickSortIter()
{
int *s = (int *)malloc(n * sizeof(int));
int t = -1;
// Push the initial range of the array onto the stack
s[++t] = 0; // Starting index
s[++t] = n - 1; // Ending index
// Continue sorting while there are elements in the stack
while (t >= 0)
{
// Pop the end index and start index
int h = s[t--];
int l = s[t--];
// Perform the partitioning
int p = partition2(l, h);
// Push the left sub-array onto the stack
if (p - 1 > l)
{
s[++t] = l;
s[++t] = p - 1;
}
 // Push the right sub-array onto the stack
if (p + 1 < h)
{
s[++t] = p + 1;
s[++t] = h;
}
}
free(s);
}
void heapify(int i)
{
int largest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l < n && a[l] > a[largest])
largest = l;
if (r < n && a[r] > a[largest])
largest = r;
if (largest != i)
{
swap(&a[i], &a[largest]);
heapify(largest);
}

}
void heapSort()
{
for (int i = n / 2 - 1; i >= 0; i++)
heapify(i);
}
void mergeSort()
{
int s = 1, l1, l2, u1, u2, i, j, k, t[n];
while (s <= n)
{
l1 = 0;
k = 0;
while((l1 + s) < n)
{
l2 = l1 + s;
u1 = l2 - 1;
u2 = (u1 + s) < n ? (u1 + s) : (n - 1);
for (i = l1, j = l2;i <= u1 && j <= u2;)
if (a[i] <= a[j])
t[k++] = a[i++];
else
t[k++] = a[j++];
while (i <= u1)
t[k++] = a[i++];
while (j <= u2)
t[k++] = a[j++];
l1 = u2 + 1;
}
for (i = l1; i < n; i++)
t[k++] = a[i];
for (i = 0; i < n; i++)
a[i] = t[i];
s *= 2;
}
}
void print()
{
int i;
for (i = 0; i < n; i++)
printf("%d ", a[i]);
}
int main()
{
int i = 0, c, r;
printf("Enter size of array (1 - 100): ");
scanf("%d", &n);
for(; i < n; i++)
{
printf("Enter element %d: ", (i + 1));
scanf("%d", (a + i));
}
printf("MENU:\n1. Selection Sort\n2. Bubble Sort");
printf("\n3. Insertion Sort\n4. Shell Sort\n5. Merge Sort");
printf("\n6. Quick Sort\nOthers: Exit\n");
printf("Enter your choice: ");
scanf("%d", &c);
printf("Array before sorting: ");
print();
printf("\n");
switch (c)
{
case 1: selectionSort();
break;
case 2: bubbleSort();
break;
case 3: insertionSort();
break;
case 4: shellSort();
break;
case 5: mergeSort();
break;
case 6: quickSortIter(0, n-1);
break;
default: break;
}
printf("Array after sorting (Ascending): ");
print();
printf("\n");
return 0;
}

3. Array Sort Descending

# include <stdio.h>
# include <stdlib.h>
# define SIZE 100
int a[SIZE], i, n;
void swap(int *a, int *b)
{
int t = *a;
*a = *b;
*b = t;
}
int selectionSort()
{
int i = 0, j, temp;
for (; i < n - 1; i++)
for (j = i + 1; j < n; j++)
if(a[i] < a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
void bubbleSortUnoptimised()
{
int i = 0, j, temp;
for (; i < n - 1; i++)
{
for (j = 0; j < n - i - 1; j++)
if(a[i] < a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
void bubbleSort()
{
int i = 0, j, temp, flag = 1;
for (; i < n - 1 && flag; i++)
{
flag = 0;
for (j = 0; j < n - i - 1; j++)
if(a[i] < a[j])
{
flag = 1;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
void insertionSort()
{
int i = 1, j;
for (; i < n; i++)
{
for (j = i - 1; j >= 0 && a[i] > a[j]; j--)
a[j + 1] = a[j];
a[j + 1] = a[i];
}
}
void shellSort()
{
int i, j, gap = n / 2;
for (; gap > 0; gap /= 2)
{
for (i = gap; i < n; i++)
{
for (j = i - gap; j >= 0 && a[i] > a[j]; j -= gap)
 a[j + gap] = a[j];
a[j + gap] = a[i];
}
}
}
void merge(int l, int m, int r)
{
int i = l, j = m + 1, k = l, *temp;
temp = (int *)(malloc((r - l + 1) * sizeof(int)));
while (i <= m && j <= r)
{
if (a[i] >= a[j])
temp[k++] = a[i++];
else
temp[k++] = a[j++];
}
while (i <= m)
temp[k++] = a[i++];
while (j <= r)
temp[k++] = a[j++];
for (i = l; i <= r; i++)
a[i] = temp[i - l];
}
void mergeSortRec(int l, int r)
{
if (l < r)
{
int m = (l + r) / 2;
mergeSortRec(l, m);
mergeSortRec(m + 1, r);
merge(l, m, r);
}
}
void mergeSort()
{
int s = 1, l1, l2, u1, u2, i, j, k, t[n];
while (s <= n)
{
l1 = 0;
k = 0;
while((l1 + s) < n)
{
l2 = l1 + s;
u1 = l2 - 1;
u2 = (u1 + s) < n ? (u1 + s) : (n - 1);
for (i = l1, j = l2; i <= u1 && j <= u2;)
if (a[i] >= a[j])
t[k++] = a[i++];
else
t[k++] = a[j++];
while (i <= u1)
t[k++] = a[i++];
while (j <= u2)
t[k++] = a[j++];
l1 = u2 + 1;
}
for (i = l1; i < n; i++)
t[k++] = a[i];
for (i = 0; i < n; i++)
 a[i] = t[i];
s *= 2;
}
}
int partition(int l, int h)
{
int pivot = a[h], i = l - 1;
for (int j = l; j < h; j++)
{
if (a[j] >= pivot)
swap(&a[++i], &a[j]);
}
swap(&a[i + 1], &a[h]);
return i + 1;
}
int partition2(int l, int h)
{
int p = l;
while(l <= h)
{
while (l <= h && a[l] >= a[p])
l++;
while (l <= h && a[h] < a[p])
h--;
if (l <= h)
swap(&a[l], &a[h]);
}
swap(&a[p],&a[h]);
return h;
}
void quickSortRec(int l, int h)
{
if(l < h)
{
int p = partition(l, h);
quickSortRec(l, p - 1);
quickSortRec(p + 1, h);
}
}
void quickSortIter()
{
int *s = (int *)malloc(n * sizeof(int));
int t = -1;
// Push the initial range of the array onto the stack
s[++t] = 0; // Starting index
s[++t] = n - 1; // Ending index
// Continue sorting while there are elements in the stack
while (t >= 0)
{
// Pop the end index and start index
int h = s[t--];
int l = s[t--];
// Perform the partitioning
int p = partition2(l, h);
// Push the left sub-array onto the stack
if (p - 1 > l)
{
s[++t] = l;
s[++t] = p - 1;
 }
// Push the right sub-array onto the stack
if (p + 1 < h)
{
s[++t] = p + 1;
s[++t] = h;
}
}
free(s);
}
void print()
{
int i;
for (i = 0; i < n; i++)
printf("%d ", a[i]);
}
int main()
{
int i = 0, c, r;
printf("Enter size of array (1 - 100): ");
scanf("%d", &n);
for(; i < n; i++)
{
printf("Enter element %d: ", (i + 1));
scanf("%d", (a + i));
}
printf("MENU:\n1. Selection Sort\n2. Bubble Sort");
printf("\n3. Insertion Sort\n4. Shell Sort\n5. Merge Sort");
printf("\n6. Quick Sort\nOthers: Exit\n");
printf("Enter your choice: ");
scanf("%d", &c);
printf("Array before sorting: ");
print();
printf("\n");
switch (c)
{
case 1: selectionSort();
break;
case 2: bubbleSort();
break;
case 3: insertionSort();
break;
case 4: shellSort();
break;
case 5: mergeSort();
break;
case 6: quickSortIter(0, n-1);
break;
default: break;
}
printf("Array after sorting (Descending): ");
print();
printf("\n");
return 0;
}

4. Circular Linked List

# include <stdio.h>
# include <stdlib.h>
typedef struct list
{
int key;
struct list *next;
} NODE;
NODE *head = NULL;
void createList(int k)
{
NODE *p = (NODE*) malloc (sizeof(NODE)), *q = head;
p -> key = k;
p -> next = NULL;
if(!head)
{
head = p;
p -> next = head;
return;
}
while(q -> next)
q = q -> next;
q -> next = p;
p -> next = head;
}
void insert_first(int k)
{
NODE *p = (NODE*) malloc (sizeof(NODE)), *q = head;
p -> key = k;
p -> next = head;
while (q -> next != head)
q = q -> next;
q -> next = p;
head = p;
}
void insert_posn(int k, int pos)
{
NODE *p = (NODE*) malloc (sizeof(NODE)), *q = head;
int i;
p -> key = k;
for(i = 0; i < pos - 1; i++)
q = q -> next;
p -> next = q -> next;
q -> next = p;
}
int delete_first()
{
NODE *p = head, *q = head;
int k = head -> key;
while (q -> next != head)
q = q -> next;
head = p -> next;
p -> next = NULL;
q -> next = head;
free(p);
return k;
}
int delete_last()
{
NODE *p = head;
int k;
while (p -> next -> next != head)
 p = p -> next;
k = p -> next -> key;
p -> next -> next = NULL;
free(p -> next);
p -> next = head;
return k;
}
int delete_posn(int pos)
{
NODE *p = head, *q;
int i, k;
for(i = 0; i < pos - 1; i++)
p = p -> next;
k = p -> next -> key;
q = p -> next;
p -> next = q -> next;
q -> next = NULL;
free(q);
return k;
}
void delete_key(int k)
{
NODE *p = head, *q = NULL;
while(p != head)
{
if(p -> key == k)
{
if(q)
q -> next = p -> next;
else
head = p -> next;
free(p);
return;
}
q = p;
p = p -> next;
}
printf("Key not found\n");
}
void reverseList()
{
NODE *p = head, *q = head, *r;
while (p != head)
{
if(q)
r = q;
q = p;
p = p -> next;
q -> next = r;
}
head = q;
}
void displayList()
{
NODE *p = head;
do
{
printf("%d\t", p -> key);
p = p -> next;
 } while (p != head);
}
int main()
{
int ch, k;
printf("Circular Singly Linked List:\n");
printf("Menu:- Press:\n");
printf("1. Create Linked List or Insert node at end\n");
printf("2. Insert node at beginning\n");
printf("3. Insert node at any given position\n");
printf("4. Delete node from beginning\n");
printf("5. Delete node from end\n");
printf("6. Delete node from any given position\n");
printf("7. Delete node containing a given key\n");
printf("8. Reverse list\n");
printf("9. Display\n");
printf("10. Exit\n");
while(1)
{
printf("\nEnter your choice: ");
scanf("%d", &ch);
switch(ch)
{
case 1: printf("Enter the element: ");
scanf("%d", &k);
createList(k);
break;
case 2: printf("Enter the element: ");
scanf("%d", &k);
insert_first(k);
break;
case 3: printf("Enter the element: ");
scanf("%d", &k);
printf("Enter the position: ");
scanf("%d", &ch);
if (ch > 1)
insert_posn(k, ch);
break;
case 4: k = delete_first();
printf("Element: %d\n", k);
break;
case 5: k = delete_last();
printf("Element: %d\n", k);
break;
case 6: printf("Enter the position: ");
scanf("%d", &ch);
if (ch > 1)
{
k = delete_posn(ch);
printf("Element: %d\n", k);
}
break;
case 7: printf("Enter the key: ");
scanf("%d", &ch);
delete_key(ch);
break;
case 8: printf("Before Reversing, Elements are: ");
displayList();
reverseList();
 printf("\nAfter Reversing, Elements are: ");
displayList();
break;
case 9: printf("Elements are: ");
displayList();
break;
case 10: return 0;
default:printf("Wrong choice! Enter again: ");
scanf("%d", &ch);
}
}
return 0;
}

5. Circular Queue
# include <stdio.h>
# include <stdlib.h>
# define MAX 5
int rear = -1, front = -1;
int queue[MAX];
void enQue(int e)
{
if ((rear + 1) % MAX == front)
{
printf("Queue Full\n");
return;
}
rear = (rear + 1) % MAX;
queue[rear] = e;
if (front == -1)
front = 0;
}
int deQue()
{
int e;
if (front == -1)
{
printf ("Queue Empty!\n");
return -1;
}
e = queue[front];
if (front == rear)
front = rear = -1;
else
front = (front + 1) % MAX;
return e;
}
void print()
{
int i;
if (front == -1)
{
printf ("Queue Empty!\n");
return;
}
for (i = front; i != rear; i = (i + 1) % MAX)
printf("%d ", queue[i]);
printf("%d", queue[rear]);
}
int main()
{
int queue[MAX], i, e;
printf("MENU:\n1. enQue element into Queue\n2. deQue element from Queue\n3.
Print Queue\nOthers: Exit\n");
while (1)
{
printf("Enter your choice: ");
scanf("%d", &i);
switch(i)
{
case 1: printf("Enter element: ");
scanf("%d", &e);
enQue(e);
break;
case 2: e = deQue();
if (e != -1)
printf("deQued element: %d\n", e);
break;
case 3: printf("Queue:\n");
print();
printf("\n");
break;
default: printf("Exiting...\n");
exit(0);
}
}
return 0;
}

6. Circular Queue Count

# include <stdio.h>
# include <stdlib.h>
# define MAX 5
int rear = -1, front = -1, count = 0;
int queue[MAX];
void enQue(int e)
{
if (++count == MAX)
{
printf("Queue Full\n");
return;
}
else
{
if(++rear == MAX)
rear = -1;
queue[rear] = e;
}
}
int deQue()
{
int e;
if (count-- == 0)
{
printf ("Queue Empty!\n");
return -1;
}
else
 {
e = queue[++front];
if (front == MAX)
front = -1;
return e;
}
}
void print()
{
int i = front;
if (count == 0)
{
printf ("Queue Empty!\n");
return;
}
do
{
printf("%d ", queue[i]);
i = (i + 1) % MAX;
} while (i != (rear + 1) % MAX);
}
int main()
{
int queue[MAX], i, e;
printf("MENU:\n1. enQue element into Queue\n2. deQue element from Queue\n3.
Print Queue\nOthers: Exit\n");
while (1)
{
printf("Enter your choice: ");
scanf("%d", &i);
switch(i)
{
case 1: printf("Enter element: ");
scanf("%d", &e);
enQue(e);
break;
case 2: e = deQue();
if (e != -1)
printf("deQued element: %d\n", e);
break;
case 3: printf("Queue:\n");
print();
printf("\n");
break;
default: printf("Exiting...\n");
exit(0);
}
}
return 0;
}

7. Doubly linked list

# include <stdio.h>
# include <stdlib.h>
typedef struct list
{
int key;
struct list *prev, *next;
} NODE;
NODE *head = NULL;
void createList(int k)
{
NODE *p = (NODE*) malloc (sizeof(NODE)), *q = head;
p -> key = k;
p -> next = NULL;
if(!head)
{
head = p;
p -> prev = NULL;
return;
}
while(q -> next)
q = q -> next;
q -> next = p;
p -> prev = q;
}
void insert_first(int k)
{
NODE *p = (NODE*) malloc (sizeof(NODE));
p -> key = k;
p -> next = head;
p -> prev = NULL;
head -> prev = p;
head = p;
}
void insert_posn(int k, int pos)
{
NODE *p = (NODE*) malloc (sizeof(NODE)), *q = head;
int i;
p -> key = k;
for(i = 0; i < pos - 1; i++)
q = q -> next;
p -> next = q -> next;
p -> prev = q;
(q -> next) -> prev = p;
q -> next = p;
}
int delete_first()
{
NODE *p = head;
int k = p -> key;
head = head -> next;
p -> next = NULL;
head -> prev = NULL;
free(p);
return k;
}
int delete_last()
{
NODE *p = head;
int k;
while(p -> next -> next)
p = p -> next;
k = p -> next -> key;
p -> next -> prev = NULL;
p -> next = NULL;
free(p -> next);
return k;
}
int delete_posn(int pos)
{
NODE *p = head, *q;
int i, k;
for (i = 1; i < pos - 1; i++)
p = p -> next;
k = p -> next -> key;
q = p -> next;
p -> next = q -> next;
q -> next -> prev = p;
q -> next = q -> prev = NULL;
free(q);
return k;
}
void delete_key(int k)
{
NODE *p = head;
while(p)
{
if (p -> key == k)
{
if (!(p -> prev))
{
head = p -> next;
p -> next -> prev = NULL;
}
else if (!(p -> next))
p -> prev -> next = NULL;
else
{
p -> prev -> next = p -> next;
p -> next -> prev = p -> prev;
}
free(p);
return;
}
p = p -> next;
}
printf("Element absent\n");
}
void reverseList()
{
NODE *p = head, *q = NULL;
while(p)
{
q = p -> prev;
p -> prev = p -> next;
p -> next = q;
q = p;
p = p -> prev;
}
head = q;
}
void displayList()
{
NODE *p = head;
while(p)
{
 printf("%d\t", p -> key);
p = p -> next;
}
}
int main()
{
int ch, k;
printf("Doubly Linked List:\n");
printf("Menu:- Press:\n");
printf("1. Create Linked List or Insert node at end\n");
printf("2. Insert node at beginning\n");
printf("3. Insert node at any given position\n");
printf("4. Delete node from beginning\n");
printf("5. Delete node from end\n");
printf("6. Delete node from any given position\n");
printf("7. Delete node containing a given key\n");
printf("8. Reverse list\n");
printf("9. Display\n");
printf("10. Exit\n");
while(1)
{
printf("\nEnter your choice: ");
scanf("%d", &ch);
switch(ch)
{
case 1: printf("Enter the element: ");
scanf("%d", &k);
createList(k);
break;
case 2: printf("Enter the element: ");
scanf("%d", &k);
insert_first(k);
break;
case 3: printf("Enter the element: ");
scanf("%d", &k);
printf("Enter the position: ");
scanf("%d", &ch);
if (ch > 1)
insert_posn(k, ch);
break;
case 4: k = delete_first();
printf("Element: %d\n", k);
break;
case 5: k = delete_last();
printf("Element: %d\n", k);
break;
case 6: printf("Enter the position: ");
scanf("%d", &ch);
if (ch > 1)
{
k = delete_posn(ch);
printf("Element: %d\n", k);
}
break;
case 7: printf("Enter the key: ");
scanf("%d", &ch);
delete_key(ch);
break;
case 8: printf("Before Reversing, Elements are: ");
 displayList();
reverseList();
printf("\nAfter Reversing, Elements are: ");
displayList();
break;
case 9: printf("Elements are: ");
displayList();
break;
case 10: return 0;
default:printf("Wrong choice! Enter again: ");
scanf("%d", &ch);
}
}
return 0;
}

8. infix to Postfix
#include <stdio.h>
#include <stdlib.h>
#define MAX 150
char ch[MAX];
int top = -1;
void check(char);
int isExp(char);
void push(char);
char pop(void);
int pr(char);
int main()
{
char exp[MAX];
int i = 0, p1 = 0, p2 = 0;
char c;
printf("Enter the infix expression: ");
scanf("%[^\n]", exp);
printf("The postfix expression is: ");
while((c = exp[i]) != '\0')
{
if(c == ' ')
{
i++;
continue;
}
else if(! isExp(c))
printf("%c", c);
else if(isExp(c))
{
if(c == ')')
{
while(ch[top] != '(')
printf("%c", pop());
pop();
}
else if(c == '(')
push(c);
else
check(c);
}
i++;
}
 while(top > -1)
printf("%c", pop());
}
void check(char c)
{
int p1, p2;
p1 = pr(c);
p2 = pr(ch[top]);
if(p2 >= p1)
{
printf("%c", pop());
check(c);
}
else
push(c);
}
int isExp(char c)
{
if(c == '+' || c == '-' || c == '*' || c == '(' || c == ')' || c == '/' || c
== '^')
return 1;
else
return 0;
}
int pr(char c)
{
if(c == '(')
return 1;
else if(c == '+' || c == '-')
return 2;
else if(c == '*' || c == '/')
return 3;
else if(c == '^')
return 4;
}
char pop()
{
if(top == -1)
{
printf("\nStack Empty Error!");
exit(0);
}
return ch[top--];
}
void push(char a)
{
if(top++ == MAX)
{
printf("\nStack Full Error!");
exit(0);
}
ch[top] = a;
}

9. Postfix Evaluation
# include <stdio.h>
# include <stdlib.h>
# include <math.h>
# define MAX 100
# define SIZE 10
int top = -1;
void push(int stack[], int e)
{
if (++top == MAX)
{
printf("Stack Full!\n");
return;
}
stack[top] = e;
}
int pop(int stack[])
{
if (top == -1)
{
printf("Stack Empty!\n");
return -1;
}
return stack[top--];
}
int isDigit(char sym)
{
if((sym >= '0') && (sym <= '9'))
return 1;
return 0;
}
int oper(int sym, int op1, int op2)
{
switch (sym)
{
case '+': return (op1 + op2);
case '-': return (op1 - op2);
case '*': return (op1 * op2);
case '/': return (op1 / op2);
case '%': return (op1 % op2);
case '$': return (int) pow(op1, op2);
}
}
int eval(char exp[])
{
int i, op1, op2, val, j, stack[SIZE];
char c;
for (i = 0; exp[i] != '\0'; i++)
{
c = exp[i];
if (c == ' ') continue;
if (isDigit(c))
push(stack, c - '0');
else
{
op2 = pop(stack);
op1 = pop(stack);
val = oper(c, op1, op2);
push(stack, val);
}
}
return pop(stack);
}
int main()
{
char exp[MAX];
printf("Input Postfix expression: ");
scanf("%[^\n]s", exp);
printf("Value of expression is %d\n", eval(exp));
}

10. Queue
# include <stdio.h>
# include <stdlib.h>
# define MAX 100
int rear = -1, front = 0;
void enQue(int queue[], int e)
{
if (++rear == MAX)
{
printf("Queue Full!\n");
return;
}
queue[rear] = e;
}
int deQue(int queue[])
{
if (front > rear)
{
printf("Queue Empty!\n");
return -1;
}
return queue[front++];
}
void print(int queue[])
{
int i;
if (front > rear)
{
printf("Queue Empty!\n");
return;
}
for (i = front; i <= rear; i++)
printf("%d ", queue[i]);
}
int main()
{
int queue[MAX], i, e;
printf("MENU:\n1. enQue element into Queue\n2. deQue element from Queue\n3.
Print Queue\nOthers: Exit\n");
while (1)
{
printf("Enter your choice: ");
scanf("%d", &i);
switch(i)
{
case 1: printf("Enter element: ");
scanf("%d", &e);
enQue(queue, e);
break;
case 2: e = deQue(queue);
if (e != -1)
printf("deQued element: %d\n", e);
 break;
case 3: printf("Queue:\n");
print(queue);
printf("\n");
break;
default: printf("Exiting...\n");
exit(0);
}
}
return 0;
}

11. Queue Shift

# include <stdio.h>
# include <stdlib.h>
# define MAX 100
int rear = -1;
void enQue(int queue[], int e)
{
if (++rear == MAX)
{
printf("Queue Full!\n");
return;
}
queue[rear] = e;
}
int deQue(int queue[])
{
int e, i;
if (rear == -1)
{
printf("Queue Empty!\n");
return -1;
}
e = queue[0];
for (i = 0; i < rear; i++)
queue[i] = queue[i + 1];
rear--;
return e;
}
void print(int queue[])
{
int i = 0;
if (rear == -1)
{
printf("Queue Empty!\n");
return;
}
for (; i <= rear; i++)
printf("%d ", queue[i]);
}
int main()
{
int queue[MAX], i, e;
printf("MENU:\n1. enQue element into Queue\n2. deQue element from Queue\n3.
Print Queue\nOthers: Exit\n");
while (1)
{
printf("Enter your choice: ");
 scanf("%d", &i);
switch(i)
{
case 1: printf("Enter element: ");
scanf("%d", &e);
enQue(queue, e);
break;
case 2: e = deQue(queue);
if (e != -1)
printf("deQued element: %d\n", e);
break;
case 3: printf("Queue:\n");
print(queue);
printf("\n");
break;
default: printf("Exiting...\n");
exit(0);
}
}
return 0;
}

12. Singly Linked List

# include <stdio.h>
# include <stdlib.h>
typedef struct list
{
int key;
struct list *next;
} NODE;
NODE *head = NULL;
void createList(int k)
{
NODE *p = (NODE*) malloc (sizeof(NODE)), *q = head;
p -> key = k;
p -> next = NULL;
if(!head)
{
head = p;
return;
}
while(q -> next)
q = q -> next;
q -> next = p;
}
void insert_first(int k)
{
NODE *p = (NODE*) malloc (sizeof(NODE));
p -> key = k;
p -> next = head;
head = p;
}
void insert_posn(int k, int pos)
{
NODE *p = (NODE*) malloc (sizeof(NODE)), *q = head;
int i;
p -> key = k;
for(i = 0; i < pos - 1; i++)
q = q -> next;
 p -> next = q -> next;
q -> next = p;
}
int delete_first()
{
NODE *p = head;
int k = p -> key;
head = head -> next;
p -> next = NULL;
free(p);
return k;
}
int delete_last()
{
NODE *p = head;
int k;
while(p -> next -> next)
p = p -> next;
k = p -> next -> key;
p -> next = NULL;
free(p -> next);
return k;
}
int delete_posn(int pos)
{
NODE *p = head, *q = NULL;
int i, k;
for(i = 0; i < pos - 1; i++)
p = p -> next;
k = p -> next -> key;
q = p -> next;
p -> next = q -> next;
q -> next = NULL;
free(q);
return k;
}
void delete_key(int k)
{
NODE *p = head, *q = NULL;
while(p)
{
if(p -> key == k)
{
if(q)
q -> next = p -> next;
else
head = p -> next;
free(p);
return;
}
q = p;
p = p -> next;
}
printf("Key not found\n");
}
void reverseList()
{
NODE *p = head, *q = NULL, *r;
while (p)
 {
if(q)
r = q;
q = p;
p = p -> next;
q -> next = r;
}
head = q;
}
void displayList()
{
NODE *p = head;
while(p)
{
printf("%d\t", p -> key);
p = p -> next;
}
}
int main()
{
int ch, k;
printf("Singly Linked List:\n");
printf("Menu:- Press:\n");
printf("1. Create Linked List or Insert node at end\n");
printf("2. Insert node at beginning\n");
printf("3. Insert node at any given position\n");
printf("4. Delete node from beginning\n");
printf("5. Delete node from end\n");
printf("6. Delete node from any given position\n");
printf("7. Delete node containing a given key\n");
printf("8. Reverse list\n");
printf("9. Display\n");
printf("10. Exit\n");
while(1)
{
printf("\nEnter your choice: ");
scanf("%d", &ch);
switch(ch)
{
case 1: printf("Enter the element: ");
scanf("%d", &k);
createList(k);
break;
case 2: printf("Enter the element: ");
scanf("%d", &k);
insert_first(k);
break;
case 3: printf("Enter the element: ");
scanf("%d", &k);
printf("Enter the position: ");
scanf("%d", &ch);
if (ch > 1)
insert_posn(k, ch);
break;
case 4: k = delete_first();
printf("Element: %d\n", k);
break;
case 5: k = delete_last();
printf("Element: %d\n", k);
 break;
case 6: printf("Enter the position: ");
scanf("%d", &ch);
if (ch > 1)
{
k = delete_posn(ch);
printf("Element: %d\n", k);
}
break;
case 7: printf("Enter the key: ");
scanf("%d", &ch);
delete_key(ch);
break;
case 8: printf("Before Reversing, Elements are: ");
displayList();
reverseList();
printf("\nAfter Reversing, Elements are: ");
displayList();
break;
case 9: printf("Elements are: ");
displayList();
break;
case 10: return 0;
default:printf("Wrong choice! Enter again: ");
scanf("%d", &ch);
}
}
return 0;
}

13. Stack
# include <stdio.h>
# include <stdlib.h>
# define MAX 100
int top = -1;
void push(int stack[], int e)
{
if (++top == MAX)
{
printf("Stack Full!\n");
return;
}
stack[top] = e;
}
int pop(int stack[])
{
if (top == -1)
{
printf("Stack Empty!\n");
return -1;
}
return stack[top--];
}
void print(int stack[])
{
int i;
if (top == -1)
{
printf("Stack Empty!\n");
 return;
}
for (i = top; i >= 0; i--)
printf("%d\n", stack[i]);
}
int main()
{
int stack[MAX], i, e;
printf("MENU:\n1. Push element into Stack\n2. Pop element from Stack\n3. Print
Stack\nOthers: Exit\n");
while (1)
{
printf("Enter your choice: ");
scanf("%d", &i);
switch(i)
{
case 1: printf("Enter element: ");
scanf("%d", &e);
push(stack, e);
break;
case 2: e = pop(stack);
if (e != -1)
printf("Popped element: %d\n", e);
break;
case 3: printf("Stack:\n");
print(stack);
printf("\n");
break;
default: printf("Exiting...\n");
exit(0);
}
}
return 0;
}