Data Structure in C (Lab Programs)

2013
Saket Kr. Pathak Software Developer 3D Graphics
Data Structure in C (Lab. Programs)

Programs are complete in best of my knowledge with zero compilation error in IDE Bloodshed Dev-C++. These can be easily portable to any versions of Visual Studio or Qt. If you need any guidance please let me know via comments and Always Enjoy Programming.

Content (Programs List) S. No. Subject WAP in C for following Sorting Methods 1. Date Sign Remark
2. 3.
4.
5. 6.
7. 8. 9.
Bubble Sort Merge Sort Insertion Sort Selection Sort Quick Sort WAP in C for following Searching Methods Linear Search Binary Search WAP in C for array implementation of Stack Queue Circular Queue Linked List WAP in C using dynamic memory allocation of Stack Queue Circular Queue Linked List WAP in C for implementation of Binary Tree. WAP in C for Tree Traversal Pre-Order In-Order Post-Order WAP in C for Graph Traversal Breadth First Search Depth First Search WAP in C for Minimum Cost Spanning Tree WAP in C for Shortest Path Problem
Saket Kr. Pathak
Page 2
1. WAP in C for following Sorting Methods Bubble Sort Merge Sort Insertion Sort Selection Sort Quick Sort Program: Bubble Sort: Algorithm [1] Compare each pair of adjacent elements from the beginning of an array and, if they are in reversed order, swap them. [2] If at least one swap has been done, repeat step 1. Time Complexity Best case: Average case: Worst case: Code Snippet: #include <stdio.h> int* bubble_sort(int i_store[], int i_size); int* get_elem(int i_size); void disp_elem(int i_store[], int i_size); int main() { printf("\n\n\n"); printf("\t\t\tWAP of Bubble sort."); printf("\n\n\n"); int i_store_size; printf("Enter the total number of items to store: "); scanf("%d", &i_store_size); int* ip_store = get_elem(i_store_size); ip_store = bubble_sort(ip_store, i_store_size); O (n) time O (n2) time O (n2) time
Saket Kr. Pathak
Page 3

printf("\n\nResult: \n"); disp_elem(ip_store, i_store_size); printf("\n\n\n"); system("pause"); return 0; } int* get_elem(int i_size) { int* ip_store = malloc(sizeof(int) * i_size); int i_count = 0; int i_temp_size = i_size; while (i_temp_size) { printf("\nEnter item for index - %d : ", i_count); scanf("%d", (ip_store+i_count)); i_count++; i_temp_size--; } disp_elem(ip_store, i_size); return ip_store; } int* bubble_sort(int i_store[], int i_size) { int i_temp; int i_count_0, i_count_1; printf("\n\nSwapping Steps: \n"); for (i_count_0 = (i_size - 1); i_count_0 > 0; --i_count_0) { for (i_count_1 = 1; i_count_1 <= i_count_0; ++i_count_1) { if (i_store[i_count_1 - 1] > i_store[i_count_1]) { i_temp = i_store[i_count_1 - 1]; i_store[i_count_1 - 1] = i_store[i_count_1]; i_store[i_count_1] = i_temp; disp_elem(i_store, i_size); } } Saket Kr. Pathak Page 4

} return i_store; } void disp_elem(int i_store[], int i_size) { printf("\n------------------------------------------------------\n"); printf("Elements stored in order: "); int i_ndx = 0; while (i_size) { printf("| %d |",i_store[i_ndx]); i_ndx++; i_size--; } printf("\n------------------------------------------------------"); } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~ Merge Sort: Algorithm [1] If the input sequence has fewer than two elements, return. [2] Partition the input sequence into two halves. [3] Sort the two subsequences using the same algorithm. [4] Merge the two sorted subsequences to form the output sequence. Time Complexity Best case: Average case: Worst case: Code Snippet: #include<stdio.h> #include<stdbool.h> #define ARRAY_SIZE 1024 Saket Kr. Pathak Page 5 O (n * log (n)) time O (n * log (n)) time O (n * log (n)) time

int i_size; int* get_elements(void); void disp_elements(int*); void divide_(int* i_store, int i_low, int i_high, bool b_flag); void conquer_(int* ip_storage, int i_low, int i_mid, int i_high); void combine_(int* storage, int* temp_arr_1, int* temp_arr_2, int i_low, int i_height); int main() { printf("\n\n\n"); printf("\t\t\tWAP of Merge sort."); printf("\n\n\n"); int* i_store; i_store = get_elements(); divide_(i_store, 0, i_size-1, 0); disp_elements(i_store); getch(); return 0; } void divide_(int* i_store, int i_low, int i_high, bool b_flag) { printf("\nDivide low(%d) | high(%d) | flag(%d): ", i_low, i_high, b_flag); int i_count; for (i_count = i_low; i_count <= i_high; ++i_count) { printf("%d", *(i_store + i_count)); } int i_mid = (i_low + i_high) / 2; if (i_low < i_high) { divide_(i_store, i_low, i_mid, 1); divide_(i_store, i_mid + 1, i_high, 0); conquer_(i_store, i_low, i_mid, i_high); } } Saket Kr. Pathak Page 6

void conquer_(int* ip_storage, int i_low, int i_mid, int i_high) { int* ip_temp_store_1 = malloc(sizeof(int) * ARRAY_SIZE); int* ip_temp_store_2 = malloc(sizeof(int) * ARRAY_SIZE); int n1,n2,i,j,k; n1 = i_mid - i_low + 1; n2 = i_high - i_mid; printf("\n\tMerge low(%d) | mid(%d) | high(%d): ", i_low, i_mid, i_high); printf("\n\tip_temp_store_1: "); for(i=0; i<n1; i++) { ip_temp_store_1[i] = ip_storage[i_low+i]; printf("%d", i, ip_temp_store_1[i]); } printf("\n\tip_temp_store_2: "); for(j=0; j<n2; j++) { ip_temp_store_2[j] = ip_storage[i_mid+j+1]; printf("%d", j, ip_temp_store_2[j]); } // To mark the end of each temporary array ip_temp_store_1[i] = 10000000; ip_temp_store_2[j] = 10000000; combine_(ip_storage, ip_temp_store_1, ip_temp_store_2, i_low, i_high); } void combine_(int* storage, int* temp_arr_1, int* temp_arr_2, int i_low, int i_height) { int i=0; int j=0; int k; printf("\nResult: "); for (k=i_low; k<=i_height; k++) { if (temp_arr_1[i] <= temp_arr_2[j]) storage[k] = temp_arr_1[i++]; else Saket Kr. Pathak Page 7

storage[k]=temp_arr_2[j++]; printf("%d", storage[k]); } printf("\n"); } void disp_elements(int* i_storage) { printf("\n\n\n"); int i_count; printf("Elements: "); for (i_count = 0; i_count < i_size; ++i_count) { printf("%d",*(i_storage + i_count)); } printf("\n\n\n"); } int* get_elements(void) { int i_count; printf("Enter the size of array: "); scanf("%d",&i_size); int* i_storage = (int*) malloc(sizeof(int) * i_size); for(i_count = 0; i_count < i_size; i_count++) { printf("Enter the element at pos[%d]: ", i_count); scanf("%d",(i_storage + i_count)); } return i_storage; } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~ Insertion Sort: Algorithm Saket Kr. Pathak Page 8

[1] Start with the result as the first element of the input. [2] Loop over the input until it is empty, "removing" the first remaining (leftmost) element. [3] Compare the removed element against the current result, starting from the highest (rightmost) element, and working left towards the lowest element. [4] If the removed input element is lower than the current result element, copy that value into the following element to make room for the new element below, and repeat with the next lowest result element. [5] Otherwise, the new element is in the correct location; save it in the cell left by copying the last examined result up, and start again from (2) with the next input element. Time Complexity Best case: Average case: Worst case: Code Snippet: #include <stdio.h> int* insertion_sort(int i_store[], int i_size); int* get_elem(int i_size); void disp_elem(int i_store[], int i_size); int main() { printf("\n\n\n"); printf("\t\t\tWAP of Insertion sort."); printf("\n\n\n"); int i_store_size; printf("Enter the total number of items to store: "); scanf("%d", &i_store_size); int* ip_store = get_elem(i_store_size); ip_store = insertion_sort(ip_store, i_store_size); disp_elem(ip_store, i_store_size); printf("\n\n\n"); system("pause"); return 0; } int* get_elem(int i_size) Saket Kr. Pathak Page 9 O (n) time O (n2) time O (n2) time

{ int* ip_store = malloc(sizeof(int) * i_size); int i_count = 0; while (i_size) { printf("\nEnter item for index - %d : ", i_count); scanf("%d", (ip_store+i_count)); i_count++; i_size--; } return ip_store; } int* insertion_sort(int i_store[], int i_size) { int i_temp; int i_count_0, i_count_1, i_count_2; for (i_count_0 = 1; i_count_0 <= (i_size-1); ++i_count_0) { for (i_count_1 = 0; i_count_1 < i_count_0; ++i_count_1) { if (i_store[i_count_1] > i_store[i_count_0]) { i_temp = i_store[i_count_1] ; i_store[i_count_1] = i_store[i_count_0] ; for (i_count_2 = i_count_0; i_count_2 > i_count_1; i_count_2--) i_store[i_count_2] = i_store[i_count_2 - 1] ; i_store[i_count_2 + 1] = i_temp ; } } } return i_store; } void disp_elem(int i_store[], int i_size) { printf("\nDisplaying Elements of store: "); int i_ndx = 0; while (i_size) { printf("%d", i_store[i_ndx]); Saket Kr. Pathak Page 10

i_ndx++; i_size--; } } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~ Selection Sort: Algorithm [1] Get a hand of unsorted cards/numbers. [2] Set a marker for the sorted section after the first card of the hand. [3] Repeat steps 4 through 6 until the unsorted section is empty. [4] Select the first unsorted card. [5] Swap this card to the left until it arrives at the correct sorted position. [6] Advance the marker to the right one card. [7] Stop Time Complexity Best case: Average case: Worst case: Code Snippet: #include <stdio.h> int* selection_sort(int i_store[], int i_size); int* get_elem(int i_size); void disp_elem(int i_store[], int i_size); int main() { printf("\n\n\n"); printf("\t\t\tWAP of Selection sort."); printf("\n\n\n"); int i_store_size; printf("Enter the total number of items to store: "); scanf("%d", &i_store_size); int* ip_store = get_elem(i_store_size); ip_store = selection_sort(ip_store, i_store_size); Saket Kr. Pathak Page 11 O (n2) time O (n2) time O (n2) time

disp_elem(ip_store, i_store_size); printf("\n\n\n"); system("pause"); return 0; } int* get_elem(int i_size) { int* ip_store = malloc(sizeof(int) * i_size); int i_count = 0; while (i_size) { printf("\nEnter item for index - %d : ", i_count); scanf("%d", (ip_store+i_count)); i_count++; i_size--; } return ip_store; } int* selection_sort(int i_store[], int i_size) { int i_temp; int i_count_0, i_count_1; for (i_count_0 = 0; i_count_0 < (i_size-1); ++i_count_0) { for (i_count_1 = (i_count_0+1); i_count_1 < i_size; ++i_count_1) { if (i_store[i_count_0] > i_store[i_count_1]) { i_temp = i_store[i_count_0]; i_store[i_count_0] = i_store[i_count_1]; i_store[i_count_1] = i_temp; } } } return i_store; } void disp_elem(int i_store[], int i_size) { printf("\nDisplaying Elements of store: "); int i_ndx = 0; Saket Kr. Pathak Page 12

while (i_size) { printf("%d", i_store[i_ndx]); i_ndx++; i_size--; } } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~ Quick Sort: Algorithm [1] Choosing the pivot. [2] Partitioning. [3] Recursively quick-sort the left and the right parts. Time Complexity Best case: Average case: Worst case: Code Snippet: #include <stdio.h> int* quick_sort(int i_store[], int i_start, int i_end); int* get_elem(int i_size); void disp_elem(int i_store[], int i_size); int main() { printf("\n\n\n"); printf("\t\t\tWAP of Quick sort."); printf("\n\n\n"); int i_store_size; printf("Enter the total number of items to store: "); scanf("%d", &i_store_size); int* ip_store = get_elem(i_store_size); ip_store = quick_sort(ip_store, 0, i_store_size); disp_elem(ip_store, i_store_size); Saket Kr. Pathak Page 13 O (n * log (n)) time O (n * log (n)) time O (n2) time

printf("\n\n\n"); system("pause"); return 0; } int* get_elem(int i_size) { int* ip_store = malloc(sizeof(int) * i_size); int i_count = 0; while (i_size) { printf("\nEnter item for index - %d : ", i_count); scanf("%d", (ip_store+i_count)); i_count++; i_size--; } return ip_store; } int* quick_sort(int i_store[], int i_start, int i_end) { int i_begin, i_finish, i_pivot, i_temp; if (i_finish > i_begin) { i_begin = i_start; i_finish = i_end; i_pivot = i_begin; while (i_begin < i_finish) { while ((i_store[i_begin] <= i_store[i_pivot]) && (i_begin < i_end)) { ++i_begin; } while (i_store[i_finish] > i_store[i_pivot]) { --i_finish; } if (i_begin < i_finish) { i_temp = i_store[i_begin]; Saket Kr. Pathak Page 14

i_store[i_begin] = i_store[i_finish]; i_store[i_finish] = i_temp; } } i_temp = i_store[i_pivot]; i_store[i_pivot] = i_store[i_finish]; i_store[i_finish] = i_temp; quick_sort(i_store, i_start, i_finish - 1); quick_sort(i_store, i_finish + 1, i_end); } return i_store; } void disp_elem(int i_store[], int i_size) { printf("\nDisplaying Elements of store: "); int i_ndx = 0; while (i_size) { printf("%d", i_store[i_ndx]); i_ndx++; i_size--; } } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~
Saket Kr. Pathak
Page 15

2. WAP in C for following Searching Methods Linear Search Binary Search Program: Linear Search: Algorithm [1] Input: Array D of Business objects, phone number key. [2] Output: first index where keys phone number matches D, or -1 if not found Time Complexity Best case: Average case: Worst case: Code Snippet: #include #include #include #include #include <stdio.h> <stdlib.h> <string.h> <stdbool.h> <math.h> O (1) time O (n) time O (n) time
void linear_search(int* i_storage, int i_srch_item, int i_num_item) { int i_count; bool b_flag = false; for (i_count = 0; i_count < i_num_item; ++i_count) { if (i_storage[i_count] == i_srch_item) { b_flag = true; printf("Item (%d) is found at position: %d", i_srch_item, i_count); break; } } if (!b_flag) Saket Kr. Pathak Page 16

printf("Item not found."); } void get_input(int* i_storage, int i_num_item) { printf("Your Storage Items are: \n\t"); int i_loop_count; for(i_loop_count = 0; i_loop_count < i_num_item; ++i_loop_count) { printf("%d, ", i_storage[i_loop_count]); } printf("\n\n\n"); int i_srch_item; printf("Please Enter the item (number) to search: "); scanf("%d", &i_srch_item); printf("\n\n\n"); linear_search(i_storage, i_srch_item, i_num_item); } void set_argument(void) { printf("WAP for Linear - Search."); printf("\nLimitation: \n\t-> Items are restrickted with integer number.\n\t-> Starting index of storage is 0."); printf("\n\n\n"); int i_storage[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; get_input(i_storage, (sizeof(i_storage)/sizeof(int))); } int main() { set_argument(); printf("\n\n\n"); getch(); return 0; } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~ Saket Kr. Pathak Page 17

Binary Search: Algorithm [1] Get the middle element; [2] If the middle element equals to the searched value, the algorithm stops; [3] Otherwise, two cases are possible: Searched value is less, than the middle element. In this case, go to the step 1 for the part of the array, before middle element. Searched value is greater, than the middle element. In this case, go to the step 1 for the part of the array, after middle element. Time Complexity Best case: Average case: Worst case: Code Snippet: #include #include #include #include #include <stdio.h> <stdlib.h> <string.h> <stdbool.h> <math.h> O (1) time O (log (n)) time O (n) time
bool check_item_order(int* i_storage) { //Function to check the Item - List is in Sorted order. return true; } void recursive_bin_search(int* i_storage, int i_srch_item, int i_low, int i_mid, int i_hi) { if(i_low < i_hi) { if(i_storage[i_mid] == i_srch_item) { printf("Item (%d) is found at position: %d", i_srch_item, i_mid); } else if(i_storage[i_mid] > i_srch_item) { i_hi = i_mid; i_mid = (i_low + i_hi)/2;
Saket Kr. Pathak
Page 18

recursive_bin_search(i_storage, i_srch_item, i_low, i_mid, i_hi); } else if(i_storage[i_mid] < i_srch_item) { i_low = i_mid; i_mid = (i_low + i_hi)/2; recursive_bin_search(i_storage, i_srch_item, i_low, i_mid, i_hi); } } } void recursive_binary_search(int* i_storage, int i_num_item) { bool b_check = check_item_order(i_storage); printf("Your Storage Items are: \n\t"); int i_loop_count; for(i_loop_count = 0; i_loop_count < i_num_item; ++i_loop_count) { printf("%d, ", i_storage[i_loop_count]); } printf("\n\n\n"); int i_srch_item; printf("Please Enter the item (number) to search: "); scanf("%d", &i_srch_item); printf("\n\n\n"); int i_low = 0; int i_hi = i_num_item; int i_mid = (i_low + i_hi)/2; if(b_check) recursive_bin_search(i_storage, i_srch_item, i_low, i_mid, i_hi); else printf("\nItems are not in Order.\n"); } void binary_search(void) Saket Kr. Pathak Page 19

{ printf("WAP for Binary - Search."); printf("\nLimitation: \n\t-> Items are restrickted with integer number.\n\t-> Starting index of storage is 0."); printf("\n\n\n"); int i_storage[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; recursive_binary_search(i_storage, (sizeof(i_storage)/sizeof(int))); } int main() { binary_search(); printf("\n\n\n"); getch(); return 0; } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~
Saket Kr. Pathak
Page 20

3. WAP in C for array implementation of Stack Queue Circular Queue Linked List Program: Stack: Code Snippet: #include <stdio.h> #include <stdbool.h> #define STACK_SIZE 1024 int i_top = -1; int stack[STACK_SIZE]; int select_choice(void) { { printf("\n\tTo printf("\n\tTo printf("\n\tTo printf("\n\tTo }
Push Item: \t\t(Press) 1"); Pop Item: \t\t(Press) 2"); Display Item: \t(Press) 3"); Exit: \t\t(Press) 4");
int i_choice; printf("\n\n\tPlease Enter Your Choice: "); scanf("%d", &i_choice); if((i_choice > 0) && (i_choice < 5)) return i_choice; else return 0; } int push_item(int i_item) { if(i_top == (STACK_SIZE - 1)) { printf("\n\tStack Overflow."); return 0; } else Saket Kr. Pathak Page 21

{ stack[++i_top] = i_item; printf("\n\tItem - %d, has successfully pushed into Stack.", i_item); return 1; } } int pop_item(int i_item) { if(i_top == -1) { printf("\n\tStack is Underflow."); return 0; } else { bool b_flag = false; int i_count; for(i_count = 0; i_count <= i_top; ++i_count) { if((stack[i_count] == i_item)&&(!b_flag)) { stack[i_count] = stack[i_count+1]; b_flag = true; } else if(b_flag) { stack[i_count] = stack[i_count+1]; } } i_top = (i_count - 2); //Substracting: 2 = (additional loop increment + 1 deleted item) return 1; } } int disp_item(void) { if(i_top == -1) { printf("\n\tStack is Empty."); return 0; } else { Saket Kr. Pathak Page 22

int i_count; printf("\n\tElements of Stack are:"); for(i_count = 0; i_count <= i_top; ++i_count) { printf("\n\tIndex: %d | Item: %d", i_count, stack[i_count]); } return 1; } } int process_stack(int i_choice) { switch(i_choice) { case 1: { printf("\n\tTo Push Item into Stack."); int i_item = 0; printf("\n\tPlease Enter the item: "); scanf("%d", &i_item); int i_check = push_item(i_item); if(i_check == 1) return 1; else return 0; break; } case 2: { printf("\n\tTo Pop Item from Stack."); int i_item = 0; printf("\n\tPlease Enter the item: "); scanf("%d", &i_item); int i_check = pop_item(i_item); if(i_check == 1) return 1; else return 0; break; } case 3: { printf("\n\tTo Display Item of Stack."); int i_check = disp_item(); if(i_check == 1) return 1; Saket Kr. Pathak Page 23

else return 0; break; } case 4: { printf("\n\tTo Exit."); return 0; break; } default: { return 0; break; } } } int set_Argument(void) { printf("\n\t-------------------------------------------------\n"); printf("\n\t\t\t Array - Container.\n"); printf("\n\t-------------------------------------------------\n\n"); int i_check = select_choice(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else ; return i_check; } int main() { int i_check = set_Argument(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else { int i_state; do { i_state = process_stack(i_check); i_check = set_Argument(); if(i_check == 4) //Check for Exit. Saket Kr. Pathak Page 24

i_state = 0; } while(i_state == 1); } printf("\n\n\n"); getch(); return 0; } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~ Queue: Code Snippet: #include <stdio.h> #include <stdbool.h> #define QUEUE_SIZE 1024 int i_front = -1; int i_rear = -1; int queue[QUEUE_SIZE]; int main() { int i_check = set_Argument(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else { int i_state; do { i_state = process_stack(i_check); i_check = set_Argument(); if(i_check == 4) for Exit. i_state = 0; } while(i_state == 1); } printf("\n\n\n"); Saket Kr. Pathak Page 25
//Check

getch(); return 0; } int set_Argument(void) { printf("\n\t-------------------------------------------------\n"); printf("\n\t\t\t Array - Container.\n"); printf("\n\t-------------------------------------------------\n\n"); int i_check = select_choice(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else ; return i_check; } int select_choice(void) { { printf("\n\tTo printf("\n\tTo printf("\n\tTo printf("\n\tTo }
int i_choice; printf("\n\n\tPlease Enter Your Choice: "); scanf("%d", &i_choice); if((i_choice > 0) && (i_choice < 5)) return i_choice; else return 0; } int push_item(int i_item) { if(i_rear == (QUEUE_SIZE - 1)) { printf("\n\tQueue Overflow."); return 0; } else Saket Kr. Pathak Page 26

{ i_front = 0; queue[++i_rear] = i_item; printf("\n\tItem - %d, has successfully pushed into Stack.", i_item); return 1; } } int pop_item(int i_item) { if((i_front == -1)||(i_front > i_rear)) { printf("\n\tQueue is Underflow."); return 0; } else { bool b_flag = false; int i_count; for(i_count = i_front; i_count <= i_rear; ++i_count) { if((queue[i_count] == i_item)&&(!b_flag)) { queue[i_count] = queue[i_count+1]; b_flag = true; } else if(b_flag) { queue[i_count] = queue[i_count+1]; } } i_rear = (i_count - 2); //Substracting: 2 = (additional loop increment + 1 deleted item) return 1; } } int disp_item(void) { if(i_front == -1) { printf("\n\tQueue is Empty."); return 0; } else Saket Kr. Pathak Page 27

{ printf("\n\tElements of Queue are:"); int i_count; for(i_count = i_front; i_count <= i_rear; ++i_count) { printf("\n\tIndex: %d | Item: %d", i_count, queue[i_count]); } return 1; } } int process_stack(int i_choice) { switch(i_choice) { case 1: { printf("\n\tTo Push Item into Queue."); int i_item = 0; printf("\n\tPlease Enter the item: "); scanf("%d", &i_item); int i_check = push_item(i_item); if(i_check == 1) return 1; else return 0; break; } case 2: { printf("\n\tTo Pop Item from Queue."); int i_item = 0; printf("\n\tPlease Enter the item: "); scanf("%d", &i_item); int i_check = pop_item(i_item); if(i_check == 1) return 1; else return 0; break; } case 3: { printf("\n\tTo Display Item of Queue."); int i_check = disp_item(); if(i_check == 1) Saket Kr. Pathak Page 28

return 1; else return 0; break; } case 4: { printf("\n\tTo Exit."); return 0; break; } default: { return 0; break; } } } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~ Circular Queue: Code Snippet: #include <stdio.h> #include <stdbool.h> #define QUEUE_SIZE 1024 int i_front = -1; int i_rear = -1; int circular_queue[QUEUE_SIZE]; int select_choice(void) { { printf("\n\tTo printf("\n\tTo printf("\n\tTo printf("\n\tTo }
int i_choice; printf("\n\n\tPlease Enter Your Choice: "); Saket Kr. Pathak Page 29

scanf("%d", &i_choice); if((i_choice > 0) && (i_choice < 5)) return i_choice; else return 0; } int push_item(int i_item) { if(((i_front == 0) && (i_rear == (QUEUE_SIZE - 1))) || (i_front == i_rear + 1)) { printf("\n\tQueue Overflow."); return 0; } else { if(i_rear == -1) { i_rear = 0; i_front = 0; } else if(i_rear == QUEUE_SIZE-1) i_rear = 0; else i_rear++; circular_queue[i_rear] = i_item; printf("\n\tItem - %d, has successfully pushed into Stack.", i_item); return 1; } } int pop_item(int i_item) { if(i_front == -1) { printf("\n\tQueue is Underflow."); return 0; } else { bool b_flag = false; int i_count; for(i_count = i_front; i_count <= i_rear; ++i_count) { Saket Kr. Pathak Page 30

if((circular_queue[i_count] == i_item)&&(!b_flag)) { circular_queue[i_count] = circular_queue[i_count+1]; b_flag = true; } else if(b_flag) { circular_queue[i_count] = circular_queue[i_count+1]; } } i_rear = (i_count - 2); //Substracting: 2 = (additional loop increment + 1 deleted item) return 1; } } int disp_item(void) { if((i_front == -1) || (i_front == i_rear + 1)) { printf("\n\tQueue is Empty."); return 0; } else { printf("\n\tElements of Queue are:"); int i_count; for(i_count = i_front; i_count <= i_rear; ++i_count) { printf("\n\tIndex: %d | Item: %d", i_count, circular_queue[i_count]); } return 1; } } int process_stack(int i_choice) { switch(i_choice) { case 1: { printf("\n\tTo Push Item into Queue."); Saket Kr. Pathak Page 31

int i_item = 0; printf("\n\tPlease Enter the item: "); scanf("%d", &i_item); int i_check = push_item(i_item); if(i_check == 1) return 1; else return 0; break; } case 2: { printf("\n\tTo Pop Item from Queue."); int i_item = 0; printf("\n\tPlease Enter the item: "); scanf("%d", &i_item); int i_check = pop_item(i_item); if(i_check == 1) return 1; else return 0; break; } case 3: { printf("\n\tTo Display Item of Queue."); int i_check = disp_item(); if(i_check == 1) return 1; else return 0; break; } case 4: { printf("\n\tTo Exit."); return 0; break; } default: { return 0; break; } } }
Saket Kr. Pathak
Page 32

int set_Argument(void) { printf("\n\t-------------------------------------------------\n"); printf("\n\t\t\t Array - Container.\n"); printf("\n\t-------------------------------------------------\n\n"); int i_check = select_choice(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else ; return i_check; } int main() { int i_check = set_Argument(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else { int i_state; do { i_state = process_stack(i_check); i_check = set_Argument(); if(i_check == 4) //Check for Exit. i_state = 0; } while(i_state == 1); } printf("\n\n\n"); getch(); return 0; } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~ Linked List: Code Snippet: (Singly Linked List)
Saket Kr. Pathak
Page 33

#include <stdio.h> #include <stdbool.h> #define LINKED_LIST_SIZE 1024 int int int int int int set_argument(void); select_choice(void); process_stack(int i_choice); push_node(int i_item, int i_indx); disp_node(void); pop_node(int i_option);
struct node { int i_val; int i_next_idx; }ll_node[LINKED_LIST_SIZE]; int i_ll_size = 0; int main() { int i_check = set_argument(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else { int i_state; do { i_state = process_stack(i_check); i_check = set_argument(); if(i_check == 4) //Check for Exit. i_state = 0; } while(i_state == 1); } printf("\n\n\n"); getch(); return 0; } int set_argument(void) { printf("\n\t-------------------------------------------------\n"); Saket Kr. Pathak Page 34

printf("\n\t\t\t Array - Singly Linked-List.\n"); printf("\n\t-------------------------------------------------\n\n"); int i_check = select_choice(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else ; return i_check; } int select_choice(void) { { printf("\n\tTo printf("\n\tTo printf("\n\tTo printf("\n\tTo }
int i_choice; printf("\n\n\tPlease Enter Your Choice: "); scanf("%d", &i_choice); if((i_choice > 0) && (i_choice < 5)) return i_choice; else return 0; } int process_stack(int i_choice) { switch(i_choice) { case 1: { printf("\n\tTo Push Item into Linked-List.\n"); int i_item = 0; int i_indx = 0; printf("\n\tPlease Enter the item: "); scanf("%d", &i_item); printf("\n\tPlease Enter the index: "); scanf("%d", &i_indx); int i_check = push_node(i_item, i_indx); if(i_check == 1) return 1; Saket Kr. Pathak Page 35

else return 0; break; } case 2: { printf("\n\tTo Pop Item from Queue."); int i_check = del_option(); { if (i_check == 0) printf("\n\n\n\tInvalid input."); else ; } i_check = pop_node(i_check); if(i_check == 1) return 1; else return 0; break; } case 3: { printf("\n\tTo Display Item of Queue."); int i_check = disp_node(); if(i_check == 1) return 1; else return 0; break; } case 4: { printf("\n\tTo Exit."); return 0; break; } default: { return 0; break; } } } int del_option(void) { Saket Kr. Pathak Page 36

printf("\n\t\t---------------------------"); { printf("\n\t\tBy Item: \t\t(Press) 1"); printf("\n\t\tBy Reference: \t\t(Press) 2"); } int i_choice; printf("\n\n\t\tPlease Enter Your Choice: "); scanf("%d", &i_choice); printf("\n\t\t---------------------------"); if((i_choice > 0) && (i_choice < 5)) return i_choice; else return 0; } int pop_node(int i_option) { if (i_option == 1) { int i_del_item; printf("\n\tItem to delete: "); scanf("%d", &i_del_item); int i_count = 0; int i_size = 0; bool b_flag = false; for (i_count = 0; i_count < (LINKED_LIST_SIZE-1), i_size < i_ll_size; ) { if ((ll_node[i_count].i_next_idx != 0)&&(!b_flag)) { if (ll_node[i_count].i_val == i_del_item) { int i_nxt_idx = ll_node[i_count].i_next_idx; ll_node[i_count].i_val = ll_node[i_nxt_idx].i_val; ll_node[i_count].i_next_idx = ll_node[i_nxt_idx].i_next_idx; i_count = i_nxt_idx; i_size++; b_flag = true; } else if (b_flag) { Saket Kr. Pathak Page 37

int i_nxt_idx = ll_node[i_count].i_next_idx; ll_node[i_count].i_val = ll_node[i_nxt_idx].i_val; ll_node[i_count].i_next_idx = ll_node[i_nxt_idx].i_next_idx; i_count = i_nxt_idx; i_size++; } else { i_count = ll_node[i_count].i_next_idx; i_size++; } } else break; } } else if (i_option == 2) { int i_del_idx; printf("\n\tIndex to delete: "); scanf("%d", &i_del_idx); int i_count = 0; int i_size = 0; bool b_flag = false; for (i_count = 0; i_count < (LINKED_LIST_SIZE-1), i_size < i_ll_size; ) { if ((ll_node[i_count].i_next_idx != 0)&&(!b_flag)) { if (ll_node[i_count].i_next_idx == i_del_idx) { int i_nxt_idx = ll_node[i_count].i_next_idx; ll_node[i_count].i_val = ll_node[i_nxt_idx].i_val; ll_node[i_count].i_next_idx = ll_node[i_nxt_idx].i_next_idx; i_count = i_nxt_idx; i_size++; b_flag = true; } else if (b_flag) { int i_nxt_idx = ll_node[i_count].i_next_idx; Saket Kr. Pathak Page 38

ll_node[i_count].i_val = ll_node[i_nxt_idx].i_val; ll_node[i_count].i_next_idx = ll_node[i_nxt_idx].i_next_idx; i_count = i_nxt_idx; i_size++; } else { i_count = ll_node[i_count].i_next_idx; i_size++; } } else break; } } return 1; } int push_node(int i_item, int i_indx) { if (i_indx < (LINKED_LIST_SIZE-1)) { ll_node[i_ll_size].i_val = i_item; ll_node[i_ll_size].i_next_idx = i_indx; i_ll_size = i_indx; //For Last Node ll_node[i_ll_size].i_val = 100001; ll_node[i_ll_size].i_next_idx = 0; //------------return 1; } else return 0; } int disp_node(void) { int i_count = 0; int i_size = 0; for (i_count = 0; i_count < (LINKED_LIST_SIZE-1), i_size < i_ll_size; ) { Saket Kr. Pathak Page 39

if (ll_node[i_count].i_next_idx != 0) { printf("\n\tItem: %d", ll_node[i_count].i_val); printf("\n\tNext Index: %d", ll_node[i_count].i_next_idx); i_count = ll_node[i_count].i_next_idx; i_size++; printf("\n\t************************\n"); } else break; } return 1; } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~ Code Snippet: (Doubly Linked List) #include <stdio.h> #include <stdbool.h> #define LINKED_LIST_SIZE 1024 int int int int int int set_argument(void); select_choice(void); process_stack(int i_choice); push_node(int i_item, int i_indx); disp_node(void); pop_node(int i_option);
struct node { int i_prev_idx; int i_val; int i_next_idx; }ll_node[LINKED_LIST_SIZE]; int i_ll_size = 0; int main() { int i_check = set_argument(); Saket Kr. Pathak Page 40

if(i_check == 0) printf("\n\n\n\tInvalid input."); else { int i_state; do { i_state = process_stack(i_check); i_check = set_argument(); if(i_check == 4) //Check for Exit. i_state = 0; } while(i_state == 1); } printf("\n\n\n"); getch(); return 0; } int set_argument(void) { printf("\n\t-------------------------------------------------\n"); printf("\n\t\t\t Array - Singly Linked-List.\n"); printf("\n\t-------------------------------------------------\n\n"); int i_check = select_choice(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else ; return i_check; } int select_choice(void) { { printf("\n\tTo printf("\n\tTo printf("\n\tTo printf("\n\tTo }

scanf("%d", &i_choice); if((i_choice > 0) && (i_choice < 5)) return i_choice; else return 0; } int process_stack(int i_choice) { switch(i_choice) { case 1: { printf("\n\tTo Push Item into Linked-List.\n"); int i_item = 0; int i_indx = 0; printf("\n\tPlease Enter the item: "); scanf("%d", &i_item); printf("\n\tPlease Enter the index: "); scanf("%d", &i_indx); int i_check = push_node(i_item, i_indx); if(i_check == 1) return 1; else return 0; break; } case 2: { printf("\n\tTo Pop Item from Queue."); int i_check = del_option(); { if (i_check == 0) printf("\n\n\n\tInvalid input."); else ; } i_check = pop_node(i_check); if(i_check == 1) return 1; else return 0; break; } case 3: { Saket Kr. Pathak Page 42

printf("\n\tTo Display Item of Queue."); int i_check = disp_node(); if(i_check == 1) return 1; else return 0; break; } case 4: { printf("\n\tTo Exit."); return 0; break; } default: { return 0; break; } } } int del_option(void) { printf("\n\t\t---------------------------"); { printf("\n\t\tBy Item: \t\t(Press) 1"); printf("\n\t\tBy Reference: \t\t(Press) 2"); } int i_choice; printf("\n\n\t\tPlease Enter Your Choice: "); scanf("%d", &i_choice); printf("\n\t\t---------------------------"); if((i_choice > 0) && (i_choice < 5)) return i_choice; else return 0; } int pop_node(int i_option) { if (i_option == 1) { int i_del_item; Saket Kr. Pathak Page 43

printf("\n\tItem to delete: "); scanf("%d", &i_del_item); int i_count = 0; int i_size = 0; bool b_flag = false; for (i_count = 0; i_count < (LINKED_LIST_SIZE-1), i_size < i_ll_size; ) { if ((ll_node[i_count].i_next_idx != 0)&&(!b_flag)) { if (ll_node[i_count].i_val == i_del_item) { int i_nxt_idx = ll_node[i_count].i_next_idx; ll_node[i_count].i_prev_idx = ll_node[i_nxt_idx].i_prev_idx; ll_node[i_count].i_val = ll_node[i_nxt_idx].i_val; ll_node[i_count].i_next_idx = ll_node[i_nxt_idx].i_next_idx; i_count = i_nxt_idx; i_size++; b_flag = true; } else if (b_flag) { int i_nxt_idx = ll_node[i_count].i_next_idx; ll_node[i_count].i_prev_idx = ll_node[i_nxt_idx].i_prev_idx; ll_node[i_count].i_val = ll_node[i_nxt_idx].i_val; ll_node[i_count].i_next_idx = ll_node[i_nxt_idx].i_next_idx; i_count = i_nxt_idx; i_size++; } else { i_count = ll_node[i_count].i_next_idx; i_size++; } } else break; } } else if (i_option == 2) Saket Kr. Pathak Page 44

{ int i_del_idx; printf("\n\tIndex to delete: "); scanf("%d", &i_del_idx); int i_count = 0; int i_size = 0; bool b_flag = false; for (i_count = 0; i_count < (LINKED_LIST_SIZE-1), i_size < i_ll_size; ) { if ((ll_node[i_count].i_next_idx != 0)&&(!b_flag)) { if (ll_node[i_count].i_next_idx == i_del_idx) { int i_nxt_idx = ll_node[i_count].i_next_idx; ll_node[i_count].i_val = ll_node[i_nxt_idx].i_val; ll_node[i_count].i_next_idx = ll_node[i_nxt_idx].i_next_idx; i_count = i_nxt_idx; i_size++; b_flag = true; } else if (b_flag) { int i_nxt_idx = ll_node[i_count].i_next_idx; ll_node[i_count].i_val = ll_node[i_nxt_idx].i_val; ll_node[i_count].i_next_idx = ll_node[i_nxt_idx].i_next_idx; i_count = i_nxt_idx; i_size++; } else { i_count = ll_node[i_count].i_next_idx; i_size++; } } else break; } } return 1; Saket Kr. Pathak Page 45

} int push_node(int i_item, int i_indx) { if (i_indx < (LINKED_LIST_SIZE-1)) { if (i_ll_size == 0) { ll_node[i_ll_size].i_prev_idx = 0; ll_node[i_ll_size].i_val = i_item; ll_node[i_ll_size].i_next_idx = i_indx; i_ll_size = i_indx; } else { ll_node[i_ll_size].i_prev_idx = ll_node[i_ll_size].i_prev_idx; ll_node[i_ll_size].i_val = i_item; ll_node[i_ll_size].i_next_idx = i_indx; i_ll_size = i_indx; //For Last Node ll_node[i_ll_size].i_prev_idx = i_indx; ll_node[i_ll_size].i_val = 100001; ll_node[i_ll_size].i_next_idx = 0; //------------} return 1; } else return 0; } int disp_node(void) { int i_count = 0; int i_size = 0; for (i_count = 0; i_count < (LINKED_LIST_SIZE-1), i_size < i_ll_size; ) { if (ll_node[i_count].i_next_idx != 0) { printf("\n\tPrev Index: %d", ll_node[i_count].i_prev_idx); printf("\n\tItem: %d", ll_node[i_count].i_val);
Saket Kr. Pathak
Page 46

printf("\n\tNext Index: %d", ll_node[i_count].i_next_idx); i_count = ll_node[i_count].i_next_idx; i_size++; printf("\n\t************************\n"); } else break; } return 1; } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~
Saket Kr. Pathak
Page 47

4. WAP in C using dynamic memory allocation of Stack Queue Circular Queue Linked List Program: Stack: Code Snippet: #include <stdio.h> #include <stdbool.h> #define STACK_SIZE 1024 int i_top = -1; int *stack; int main() { int i_check = set_Argument(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else { int i_state; stack = (int*)malloc(sizeof(int) * STACK_SIZE); do { i_state = process_stack(i_check); i_check = set_Argument(); if(i_check == 4) for Exit. i_state = 0; } while(i_state == 1); } printf("\n\n\n"); getch(); return 0; } Saket Kr. Pathak Page 48 //Check

int set_Argument(void) { printf("\n\t-------------------------------------------------\n"); printf("\n\t\t\t Array - Container.\n"); printf("\n\t-------------------------------------------------\n\n"); int i_check = select_choice(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else ; return i_check; } int select_choice(void) { { printf("\n\tTo printf("\n\tTo printf("\n\tTo printf("\n\tTo }
int i_choice; printf("\n\n\tPlease Enter Your Choice: "); scanf("%d", &i_choice); if((i_choice > 0) && (i_choice < 5)) return i_choice; else return 0; } int process_stack(int i_choice) { switch(i_choice) { case 1: { printf("\n\tTo Push Item into Stack."); int i_item = 0; printf("\n\tPlease Enter the item: "); scanf("%d", &i_item); int i_check = push_item(i_item); if(i_check == 1) Saket Kr. Pathak Page 49

return 1; else return 0; break; } case 2: { printf("\n\tTo Pop Item from Stack."); int i_item = 0; printf("\n\tPlease Enter the item: "); scanf("%d", &i_item); int i_check = pop_item(i_item); if(i_check == 1) return 1; else return 0; break; } case 3: { printf("\n\tTo Display Item of Stack."); int i_check = disp_item(); if(i_check == 1) return 1; else return 0; break; } case 4: { printf("\n\tTo Exit."); return 0; break; } default: { return 0; break; } } } int push_item(int i_item) { if(i_top == (STACK_SIZE - 1)) { printf("\n\tStack Overflow."); Saket Kr. Pathak Page 50

return 0; } else { *(stack + (++i_top)) = i_item; printf("\n\tItem - %d, has successfully pushed into Stack.", i_item); return 1; } } int pop_item(int i_item) { if(i_top == -1) { printf("\n\tStack is Underflow."); return 0; } else { bool b_flag = false; int i_count; for(i_count = 0; i_count <= i_top; ++i_count) { if((*(stack + i_count) == i_item)&&(!b_flag)) { *(stack + i_count) = *(stack + (i_count+1)); b_flag = true; } else if(b_flag) { *(stack + i_count) = *(stack + (i_count+1)); } } i_top = (i_count - 2); //Substracting: 2 = (additional loop increment + 1 deleted item) return 1; } } int disp_item(void) { if(i_top == -1) { printf("\n\tStack is Empty."); return 0; Saket Kr. Pathak Page 51

} else { int i_count; printf("\n\tElements of Stack are:"); for(i_count = 0; i_count <= i_top; ++i_count) { printf("\n\tIndex: %d | Item: %d", i_count, *(stack + i_count)); } return 1; } }
~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~ Queue: Code Snippet: #include <stdio.h> #include <stdbool.h> #define QUEUE_SIZE 1024 int i_front = -1; int i_rear = -1; int *queue; int main() { int i_check = set_Argument(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else { int i_state; queue = (int*)malloc(sizeof(int) * QUEUE_SIZE); do { i_state = process_stack(i_check); i_check = set_Argument(); if(i_check == 4) //Check for Exit. Saket Kr. Pathak Page 52

i_state = 0; } while(i_state == 1); } printf("\n\n\n"); getch(); return 0; } int set_Argument(void) { printf("\n\t-------------------------------------------------\n"); printf("\n\t\t\t Array - Container.\n"); printf("\n\t-------------------------------------------------\n\n"); int i_check = select_choice(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else ; return i_check; } int select_choice(void) { { printf("\n\tTo printf("\n\tTo printf("\n\tTo printf("\n\tTo }
int i_choice; printf("\n\n\tPlease Enter Your Choice: "); scanf("%d", &i_choice); if((i_choice > 0) && (i_choice < 5)) return i_choice; else return 0; } int push_item(int i_item) { Saket Kr. Pathak Page 53

if(i_rear == (QUEUE_SIZE - 1)) { printf("\n\tQueue Overflow."); return 0; } else { i_front = 0; *(queue + (++i_rear)) = i_item; printf("\n\tItem - %d, has successfully pushed into Stack.", i_item); return 1; } } int pop_item(int i_item) { if((i_front == -1)||(i_front > i_rear)) { printf("\n\tQueue is Underflow."); return 0; } else { bool b_flag = false; int i_count; for(i_count = i_front; i_count <= i_rear; ++i_count) { if((*(queue + i_count) == i_item)&&(!b_flag)) { *(queue + i_count) = *(queue + (i_count+1)); b_flag = true; } else if(b_flag) { *(queue + i_count) = *(queue + (i_count+1)); } } i_rear = (i_count - 2); //Substracting: 2 = (additional loop increment + 1 deleted item) return 1; } } int disp_item(void) { Saket Kr. Pathak Page 54

if(i_front == -1) { printf("\n\tQueue is Empty."); return 0; } else { printf("\n\tElements of Queue are:"); int i_count; for(i_count = i_front; i_count <= i_rear; ++i_count) { printf("\n\tIndex: %d | Item: %d", i_count, *(queue + i_count)); } return 1; } } int process_stack(int i_choice) { switch(i_choice) { case 1: { printf("\n\tTo Push Item into Queue."); int i_item = 0; printf("\n\tPlease Enter the item: "); scanf("%d", &i_item); int i_check = push_item(i_item); if(i_check == 1) return 1; else return 0; break; } case 2: { printf("\n\tTo Pop Item from Queue."); int i_item = 0; printf("\n\tPlease Enter the item: "); scanf("%d", &i_item); int i_check = pop_item(i_item); if(i_check == 1) return 1; else return 0; break; Saket Kr. Pathak Page 55

} case 3: { printf("\n\tTo Display Item of Queue."); int i_check = disp_item(); if(i_check == 1) return 1; else return 0; break; } case 4: { printf("\n\tTo Exit."); return 0; break; } default: { return 0; break; } } } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~ Circular Queue: Code Snippet: #include <stdio.h> #include <stdbool.h> #define QUEUE_SIZE 1024 int i_front = -1; int i_rear = -1; int *circular_queue; int main() { int i_check = set_Argument(); if(i_check == 0) printf("\n\n\n\tInvalid input."); Saket Kr. Pathak Page 56

else { int i_state; circular_queue = (int*)malloc(sizeof(int) * QUEUE_SIZE); do { i_state = process_stack(i_check); i_check = set_Argument(); if(i_check == 4) //Check for Exit. i_state = 0; } while(i_state == 1); } printf("\n\n\n"); getch(); return 0; } int set_Argument(void) { printf("\n\t-------------------------------------------------\n"); printf("\n\t\t\t Array - Container.\n"); printf("\n\t-------------------------------------------------\n\n"); int i_check = select_choice(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else ; return i_check; } int select_choice(void) { { printf("\n\tTo printf("\n\tTo printf("\n\tTo printf("\n\tTo }

scanf("%d", &i_choice); if((i_choice > 0) && (i_choice < 5)) return i_choice; else return 0; } int push_item(int i_item) { if(((i_front == 0) && (i_rear == (QUEUE_SIZE - 1))) || (i_front == i_rear + 1)) { printf("\n\tQueue Overflow."); return 0; } else { if(i_rear == -1) { i_rear = 0; i_front = 0; } else if(i_rear == QUEUE_SIZE-1) i_rear = 0; else i_rear++; *(circular_queue + i_rear) = i_item; printf("\n\tItem - %d, has successfully pushed into Stack.", i_item); return 1; } } int pop_item(int i_item) { if(i_front == -1) { printf("\n\tQueue is Underflow."); return 0; } else { bool b_flag = false; int i_count; for(i_count = i_front; i_count <= i_rear; ++i_count) { Saket Kr. Pathak Page 58

if((*(circular_queue + i_count) == i_item)&&(!b_flag)) { *(circular_queue + i_count) = *(circular_queue + (i_count+1)); b_flag = true; } else if(b_flag) { *(circular_queue + i_count) = *(circular_queue + (i_count+1)); } } i_rear = (i_count - 2); //Substracting: 2 = (additional loop increment + 1 deleted item) return 1; } } int disp_item(void) { if((i_front == -1) || (i_front == i_rear + 1)) { printf("\n\tQueue is Empty."); return 0; } else { printf("\n\tElements of Queue are:"); int i_count; for(i_count = i_front; i_count <= i_rear; ++i_count) { printf("\n\tIndex: %d | Item: %d", i_count, *(circular_queue + i_count)); } return 1; } } int process_stack(int i_choice) { switch(i_choice) { case 1: { printf("\n\tTo Push Item into Queue."); Saket Kr. Pathak Page 59

int i_item = 0; printf("\n\tPlease Enter the item: "); scanf("%d", &i_item); int i_check = push_item(i_item); if(i_check == 1) return 1; else return 0; break; } case 2: { printf("\n\tTo Pop Item from Queue."); int i_item = 0; printf("\n\tPlease Enter the item: "); scanf("%d", &i_item); int i_check = pop_item(i_item); if(i_check == 1) return 1; else return 0; break; } case 3: { printf("\n\tTo Display Item of Queue."); int i_check = disp_item(); if(i_check == 1) return 1; else return 0; break; } case 4: { printf("\n\tTo Exit."); return 0; break; } default: { return 0; break; } } } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~ Saket Kr. Pathak Page 60

Linked List: Code Snippet: (Singly Linked List) #include <stdio.h> #include <stdbool.h> #define LINKED_LIST_SIZE 1024 int int int int int int set_argument(void); select_choice(void); process_stack(int i_choice); push_node(int i_item, int i_indx); disp_node(void); pop_node(int i_option);
struct node { int i_val; int i_next_idx; }*ll_node; int i_ll_size = 0; int main() { int i_check = set_argument(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else { int i_state; ll_node = (struct node*)malloc(sizeof(int) * LINKED_LIST_SIZE); do { i_state = process_stack(i_check); i_check = set_argument(); if(i_check == 4) //Check for Exit. i_state = 0; } while(i_state == 1); } printf("\n\n\n"); getch(); return 0; Saket Kr. Pathak Page 61

} int set_argument(void) { printf("\n\t-------------------------------------------------\n"); printf("\n\t\t\t Array - Singly Linked-List.\n"); printf("\n\t-------------------------------------------------\n\n"); int i_check = select_choice(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else ; return i_check; } int select_choice(void) { { printf("\n\tTo printf("\n\tTo printf("\n\tTo printf("\n\tTo }
int i_choice; printf("\n\n\tPlease Enter Your Choice: "); scanf("%d", &i_choice); if((i_choice > 0) && (i_choice < 5)) return i_choice; else return 0; } int process_stack(int i_choice) { switch(i_choice) { case 1: { printf("\n\tTo Push Item into Linked-List.\n"); int i_item = 0; int i_indx = 0; printf("\n\tPlease Enter the item: "); Saket Kr. Pathak Page 62

scanf("%d", &i_item); printf("\n\tPlease Enter the index: "); scanf("%d", &i_indx); int i_check = push_node(i_item, i_indx); if(i_check == 1) return 1; else return 0; break; } case 2: { printf("\n\tTo Pop Item from Queue."); int i_check = del_option(); { if (i_check == 0) printf("\n\n\n\tInvalid input."); else ; } i_check = pop_node(i_check); if(i_check == 1) return 1; else return 0; break; } case 3: { printf("\n\tTo Display Item of Queue."); int i_check = disp_node(); if(i_check == 1) return 1; else return 0; break; } case 4: { printf("\n\tTo Exit."); return 0; break; } default: { return 0; break; Saket Kr. Pathak Page 63

} } } int del_option(void) { printf("\n\t\t---------------------------"); { printf("\n\t\tBy Item: \t\t(Press) 1"); printf("\n\t\tBy Reference: \t\t(Press) 2"); } int i_choice; printf("\n\n\t\tPlease Enter Your Choice: "); scanf("%d", &i_choice); printf("\n\t\t---------------------------"); if((i_choice > 0) && (i_choice < 5)) return i_choice; else return 0; } int pop_node(int i_option) { if (i_option == 1) { int i_del_item; printf("\n\tItem to delete: "); scanf("%d", &i_del_item); int i_count = 0; int i_size = 0; bool b_flag = false; for (i_count = 0; i_count < (LINKED_LIST_SIZE-1), i_size < i_ll_size; ) { if (((*(ll_node + i_count)).i_next_idx != 0)&&(!b_flag)) { if ((*(ll_node + i_count)).i_val == i_del_item) { int i_nxt_idx = (*(ll_node + i_count)).i_next_idx; (*(ll_node + i_count)).i_val = (*(ll_node + i_nxt_idx)).i_val; Saket Kr. Pathak Page 64

(*(ll_node + i_count)).i_next_idx = (*(ll_node + i_nxt_idx)).i_next_idx; i_count = i_nxt_idx; i_size++; b_flag = true; } else if (b_flag) { int i_nxt_idx = (*(ll_node + i_count)).i_next_idx; (*(ll_node + i_count)).i_val = (*(ll_node + i_nxt_idx)).i_val; (*(ll_node + i_count)).i_next_idx = (*(ll_node + i_nxt_idx)).i_next_idx; i_count = i_nxt_idx; i_size++; } else { i_count = (*(ll_node + i_count)).i_next_idx; i_size++; } } else break; } } else if (i_option == 2) { int i_del_idx; printf("\n\tIndex to delete: "); scanf("%d", &i_del_idx); int i_count = 0; int i_size = 0; bool b_flag = false; for (i_count = 0; i_count < (LINKED_LIST_SIZE-1), i_size < i_ll_size; ) { if (((*(ll_node + i_count)).i_next_idx != 0)&&(!b_flag)) { if ((*(ll_node + i_count)).i_next_idx == i_del_idx) { int i_nxt_idx = (*(ll_node + i_count)).i_next_idx; Saket Kr. Pathak Page 65

(*(ll_node + i_count)).i_val = (*(ll_node + i_nxt_idx)).i_val; (*(ll_node + i_count)).i_next_idx = (*(ll_node + i_nxt_idx)).i_next_idx; i_count = i_nxt_idx; i_size++; b_flag = true; } else if (b_flag) { int i_nxt_idx = (*(ll_node + i_count)).i_next_idx; (*(ll_node + i_count)).i_val = (*(ll_node + i_nxt_idx)).i_val; (*(ll_node + i_count)).i_next_idx = (*(ll_node + i_nxt_idx)).i_next_idx; i_count = i_nxt_idx; i_size++; } else { i_count = (*(ll_node + i_count)).i_next_idx; i_size++; } } else break; } } return 1; } int push_node(int i_item, int i_indx) { if (i_indx < (LINKED_LIST_SIZE-1)) { (*(ll_node + i_ll_size)).i_val = i_item; (*(ll_node + i_ll_size)).i_next_idx = i_indx; i_ll_size = i_indx; //For Last Node (*(ll_node + i_ll_size)).i_val = 100001; (*(ll_node + i_ll_size)).i_next_idx = 0; //------------return 1; Saket Kr. Pathak Page 66

} else return 0; } int disp_node(void) { int i_count = 0; int i_size = 0; for (i_count = 0; i_count < (LINKED_LIST_SIZE-1), i_size < i_ll_size; ) { if ((*(ll_node + i_count)).i_next_idx != 0) { printf("\n\tItem: %d", (*(ll_node + i_count)).i_val); printf("\n\tNext Index: %d", (*(ll_node + i_count)).i_next_idx); i_count = (*(ll_node + i_count)).i_next_idx; i_size++; printf("\n\t************************\n"); } else break; } return 1; } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~ Code Snippet: (Doubly Linked List) #include <stdio.h> #include <stdbool.h> #define LINKED_LIST_SIZE 1024 int int int int int int set_argument(void); select_choice(void); process_stack(int i_choice); push_node(int i_item, int i_indx); disp_node(void); pop_node(int i_option); Page 67
Saket Kr. Pathak

struct node { int i_prev_idx; int i_val; int i_next_idx; }*ll_node; int i_ll_size = 0; int main() { int i_check = set_argument(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else { int i_state; ll_node = (struct node*)malloc(sizeof(int) * LINKED_LIST_SIZE); do { i_state = process_stack(i_check); i_check = set_argument(); if(i_check == 4) //Check for Exit. i_state = 0; } while(i_state == 1); } printf("\n\n\n"); getch(); return 0; } int set_argument(void) { printf("\n\t-------------------------------------------------\n"); printf("\n\t\t\t Array - Singly Linked-List.\n"); printf("\n\t-------------------------------------------------\n\n"); int i_check = select_choice(); if(i_check == 0) printf("\n\n\n\tInvalid input."); else ; Saket Kr. Pathak Page 68

return i_check; } int select_choice(void) { { printf("\n\tTo printf("\n\tTo printf("\n\tTo printf("\n\tTo }
int i_choice; printf("\n\n\tPlease Enter Your Choice: "); scanf("%d", &i_choice); if((i_choice > 0) && (i_choice < 5)) return i_choice; else return 0; } int process_stack(int i_choice) { switch(i_choice) { case 1: { printf("\n\tTo Push Item into Linked-List.\n"); int i_item = 0; int i_indx = 0; printf("\n\tPlease Enter the item: "); scanf("%d", &i_item); printf("\n\tPlease Enter the index: "); scanf("%d", &i_indx); int i_check = push_node(i_item, i_indx); if(i_check == 1) return 1; else return 0; break; } case 2: { printf("\n\tTo Pop Item from Queue."); int i_check = del_option(); Saket Kr. Pathak Page 69

{ if (i_check == 0) printf("\n\n\n\tInvalid input."); else ; } i_check = pop_node(i_check); if(i_check == 1) return 1; else return 0; break; } case 3: { printf("\n\tTo Display Item of Queue."); int i_check = disp_node(); if(i_check == 1) return 1; else return 0; break; } case 4: { printf("\n\tTo Exit."); return 0; break; } default: { return 0; break; } } } int del_option(void) { printf("\n\t\t---------------------------"); { printf("\n\t\tBy Item: \t\t(Press) 1"); printf("\n\t\tBy Reference: \t\t(Press) 2"); } int i_choice; printf("\n\n\t\tPlease Enter Your Choice: "); Saket Kr. Pathak Page 70

scanf("%d", &i_choice); printf("\n\t\t---------------------------"); if((i_choice > 0) && (i_choice < 5)) return i_choice; else return 0; } int pop_node(int i_option) { if (i_option == 1) { int i_del_item; printf("\n\tItem to delete: "); scanf("%d", &i_del_item); int i_count = 0; int i_size = 0; bool b_flag = false; for (i_count = 0; i_count < (LINKED_LIST_SIZE-1), i_size < i_ll_size; ) { if (((*(ll_node + i_count)).i_next_idx != 0)&&(!b_flag)) { if ((*(ll_node + i_count)).i_val == i_del_item) { int i_nxt_idx = (*(ll_node + i_count)).i_next_idx; (*(ll_node + i_count)).i_prev_idx = (*(ll_node + i_nxt_idx)).i_prev_idx; (*(ll_node + i_count)).i_val = (*(ll_node + i_nxt_idx)).i_val; (*(ll_node + i_count)).i_next_idx = (*(ll_node + i_nxt_idx)).i_next_idx; i_count = i_nxt_idx; i_size++; b_flag = true; } else if (b_flag) { int i_nxt_idx = (*(ll_node + i_count)).i_next_idx; (*(ll_node + i_count)).i_prev_idx = (*(ll_node + i_nxt_idx)).i_prev_idx; Saket Kr. Pathak Page 71

(*(ll_node + i_count)).i_val = (*(ll_node + i_nxt_idx)).i_val; (*(ll_node + i_count)).i_next_idx = (*(ll_node + i_nxt_idx)).i_next_idx; i_count = i_nxt_idx; i_size++; } else { i_count = (*(ll_node + i_count)).i_next_idx; i_size++; } } else break; } } else if (i_option == 2) { int i_del_idx; printf("\n\tIndex to delete: "); scanf("%d", &i_del_idx); int i_count = 0; int i_size = 0; bool b_flag = false; for (i_count = 0; i_count < (LINKED_LIST_SIZE-1), i_size < i_ll_size; ) { if (((*(ll_node + i_count)).i_next_idx != 0)&&(!b_flag)) { if ((*(ll_node + i_count)).i_next_idx == i_del_idx) { int i_nxt_idx = (*(ll_node + i_count)).i_next_idx; (*(ll_node + i_count)).i_val = (*(ll_node + i_nxt_idx)).i_val; (*(ll_node + i_count)).i_next_idx = (*(ll_node + i_nxt_idx)).i_next_idx; i_count = i_nxt_idx; i_size++; b_flag = true; } else if (b_flag) { Saket Kr. Pathak Page 72

int i_nxt_idx = (*(ll_node + i_count)).i_next_idx; (*(ll_node + i_count)).i_val = (*(ll_node + i_nxt_idx)).i_val; (*(ll_node + i_count)).i_next_idx = (*(ll_node + i_nxt_idx)).i_next_idx; i_count = i_nxt_idx; i_size++; } else { i_count = (*(ll_node + i_count)).i_next_idx; i_size++; } } else break; } } return 1; } int push_node(int i_item, int i_indx) { if (i_indx < (LINKED_LIST_SIZE-1)) { if (i_ll_size == 0) { (*(ll_node + i_ll_size)).i_prev_idx = 0; (*(ll_node + i_ll_size)).i_val = i_item; (*(ll_node + i_ll_size)).i_next_idx = i_indx; i_ll_size = i_indx; } else { (*(ll_node + i_ll_size)).i_prev_idx = (*(ll_node + i_ll_size)).i_prev_idx; (*(ll_node + i_ll_size)).i_val = i_item; (*(ll_node + i_ll_size)).i_next_idx = i_indx; i_ll_size = i_indx; //For Last Node (*(ll_node + i_ll_size)).i_prev_idx = i_indx; (*(ll_node + i_ll_size)).i_val = 100001; (*(ll_node + i_ll_size)).i_next_idx = 0; //------------Saket Kr. Pathak Page 73

} return 1; } else return 0; } int disp_node(void) { int i_count = 0; int i_size = 0; for (i_count = 0; i_count < (LINKED_LIST_SIZE-1), i_size < i_ll_size; ) { if (ll_node[i_count].i_next_idx != 0) { printf("\n\tPrev Index: %d", (*(ll_node + i_count)).i_prev_idx); printf("\n\tItem: %d", (*(ll_node + i_count)).i_val); printf("\n\tNext Index: %d", (*(ll_node + i_count)).i_next_idx); i_count = (*(ll_node + i_count)).i_next_idx; i_size++; printf("\n\t************************\n"); } else break; } return 1; } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~
Saket Kr. Pathak
Page 74

5. WAP in C for implementation of Binary Tree. Program: Code Snippet: #include <stdio.h> #include <stdlib.h> #include <stdbool.h> struct node { int i_data; struct node *right_node; struct node *left_node; }; struct node* get_tree_element(int i_no_elem); struct node* crea_tree(struct node *root, int i_data); bool insert_node(struct node **root, struct node *nw_node); void disp_tree(struct node *root); struct node* delete_node(struct node *current_node, int i_data); int main() { printf("\n\n\n"); printf("\t\t\tWAP for implementation of Binary Tree.."); printf("\n\n\n"); int i_tree_elem; printf("Enter the total number of elements: "); scanf("%d", &i_tree_elem); struct node *root = (struct node*)malloc(sizeof(struct node)); root = get_tree_element(i_tree_elem); printf("\n\n\n"); printf("\tWAP of Selection sort.\n"); disp_tree(root); printf("\n\n\n"); system("pause"); return 0; } struct node* get_tree_element(int i_no_elem) Saket Kr. Pathak Page 75

{ struct node *root = (struct node*)malloc(sizeof(struct node)); root = NULL; int i_count; for (i_count = 0; i_count < i_no_elem; ++i_count) { int i_temp; printf("\n\tEnter Element:%d: ", i_count); scanf("%d", &i_temp); root = crea_tree(root, i_temp); } return root; } struct node* crea_tree(struct node *root, int i_data) { struct node *current_node = (struct node*) malloc(sizeof(struct node)); current_node->i_data = i_data; current_node->left_node = current_node->right_node = NULL; insert_node(&root, current_node); return root; } bool insert_node(struct node **root, struct node *nw_node) { //Check for Null Root-Node if(!(*root)) { *root = nw_node; return true; } else { //If ITEM is less that the ITEM in Root Node //Traverse the node in LEFT - SIDE. if(nw_node->i_data < (*root)->i_data) insert_node(&(*root)->left_node, nw_node); //If ITEM is greater that the ITEM in Root Node //Traverse the node in RIGHT - SIDE. Saket Kr. Pathak Page 76

else if(nw_node->i_data > (*root)->i_data) insert_node(&(*root)->right_node, nw_node); return false; } } void disp_tree(struct node *root) { //Check for NULL in LEFT - Node if(root->left_node) disp_tree(root->left_node); printf("\nNode- Left: %d \t Right: %d \t Item: %d\n", root>left_node, root->right_node, root->i_data); //Check for NULL in RIGHT - Node if(root->right_node) disp_tree(root->right_node); } struct node* delete_node(struct node *current_node, int i_data) { struct node *parent_node = (struct node*)malloc(sizeof(struct node*)); parent_node = NULL; struct node *child_node = (struct node*)malloc(sizeof(struct node*)); child_node = NULL; struct node *temp_node = (struct node*)malloc(sizeof(struct node*)); temp_node = NULL; struct node *del_node = (struct node*)malloc(sizeof(struct node*)); del_node = NULL; while (current_node != NULL) { if (current_node->i_data > i_data) { parent_node = current_node; current_node = current_node->left_node; } else if (current_node->i_data < i_data) { parent_node = current_node; current_node = current_node->right_node; Saket Kr. Pathak Page 77

} else if (i_data == current_node->i_data) { del_node = current_node; //Node to delete is Leaf-Node if ((del_node->left_node == NULL) && (del_node>right_node == NULL)) { //If the node to delete is on the left-side if (parent_node->left_node == del_node) { printf("\n\tNode deleting with value (%d), left of the parent.", del_node->i_data); parent_node->left_node = NULL; free(del_node); break; } //If the node to delete is on the right-side else if (parent_node->right_node == del_node) { printf("\n\tNode deleting with value (%d), right of the parent.", del_node->i_data); parent_node->right_node = NULL; free(del_node); break; } } //Node to delete has one child else if ((del_node->left_node == NULL) || (del_node->right_node == NULL)) { //If the node to delete is on the left-side if (parent_node->left_node == del_node) { if (del_node->left_node != NULL) { printf("\n\tNode deleting with value (%d), left of the parent.", del_node->i_data); parent_node->left_node = del_node>left_node; free(del_node); break; } else if (del_node->right_node != NULL) {
Saket Kr. Pathak
Page 78

printf("\n\tNode deleting with value (%d), left of the parent.", del_node->i_data); parent_node->left_node = del_node>right_node; free(del_node); break; } } else if (parent_node->right_node == del_node) { if (del_node->left_node != NULL) { printf("\n\tNode deleting with value (%d), right of the parent.", del_node->i_data); parent_node->right_node = del_node>left_node; free(del_node); } else if (del_node->right_node != NULL) { printf("\n\tNode deleting with value (%d), right of the parent.", del_node->i_data); parent_node->right_node = del_node->right_node; free(del_node); } } } //Node to delete has two child else if ((del_node->left_node != NULL) && (del_node->right_node != NULL)) { printf("\n\tNode to delete has two children\n"); temp_node = del_node; //If the node to delete is Root if (parent_node == NULL) { child_node = del_node>right_node; if (child_node->left_node == NULL) { child_node->left_node = del_node->left_node; free(del_node); Saket Kr. Pathak Page 79

break; } else { while (child_node>left_node != NULL) { parent_node = child_node; child_node = parent_node->left_node; } temp_node->i_data = child_node->i_data; parent_node->left_node = child_node->right_node; del_node = child_node; free(del_node); break; } } //If the node to delete is on the Left else if (parent_node->left_node == del_node) { child_node = del_node>right_node; if (child_node->left_node == NULL) { parent_node->left_node = child_node; child_node->left_node = del_node->left_node; free(del_node); break; } else { while (child_node>left_node != NULL) { parent_node = child_node; child_node = parent_node->left_node; Saket Kr. Pathak Page 80

} temp_node->i_data = child_node->i_data; parent_node->left_node = child_node->right_node; del_node = child_node; free(del_node); break; } } //If the node to delete is on the Right else if (parent_node->right_node == del_node) { child_node = del_node>right_node; if (child_node->left_node == NULL) { parent_node->right_node = child_node; child_node->left_node = del_node->left_node; free(del_node); break; } else { while (child_node->left_node != NULL) { parent_node = child_node; child_node = parent_node>left_node; } temp_node->i_data = child_node->i_data; parent_node->left_node = child_node>right_node; del_node = child_node; free(del_node); break; } } } } }
Saket Kr. Pathak
Page 81

return current_node; } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~
Saket Kr. Pathak
Page 82

6. WAP in C for Tree Traversal Pre-Order In-Order Post-Order Program: Code Snippet: #include <stdio.h> #include <stdlib.h> #include <stdbool.h> struct node { int i_data; struct node *right_node; struct node *left_node; }; struct node* get_tree_element(int i_no_elem); struct node* crea_tree(struct node *root, int i_data); bool insert_node(struct node **root, struct node *nw_node); int disp_menu(void); void disp_tree(struct node *root); void traverse_tree(int i_choice, struct node* root); void inorder(struct node *tree_node); void preorder(struct node *tree_node); void postorder(struct node *tree_node); int main() { printf("\n\n\n"); printf("\t\t\tWAP for implementation of Binary Tree.."); printf("\n\n\n"); int i_tree_elem; printf("Enter the total number of elements: "); scanf("%d", &i_tree_elem); struct node *root = (struct node*)malloc(sizeof(struct node)); root = get_tree_element(i_tree_elem); printf("\n\n\n"); printf("\tWAP of Selection sort.\n"); Saket Kr. Pathak Page 83

disp_tree(root); int i_choice = disp_menu(); traverse_tree(i_choice, root); printf("\n\n\n"); system("pause"); return 0; } struct node* get_tree_element(int i_no_elem) { struct node *root = (struct node*)malloc(sizeof(struct node)); root = NULL; int i_count; for (i_count = 0; i_count < i_no_elem; ++i_count) { int i_temp; printf("\n\tEnter Element:%d: ", i_count); scanf("%d", &i_temp); root = crea_tree(root, i_temp); } return root; } struct node* crea_tree(struct node *root, int i_data) { struct node *current_node = (struct node*) malloc(sizeof(struct node)); current_node->i_data = i_data; current_node->left_node = current_node->right_node = NULL; insert_node(&root, current_node); return root; } bool insert_node(struct node **root, struct node *nw_node) { //Check for Null Root-Node if(!(*root)) { Saket Kr. Pathak Page 84

*root = nw_node; return true; } else { //If ITEM is less that the ITEM in Root Node //Traverse the node in LEFT - SIDE. if(nw_node->i_data < (*root)->i_data) insert_node(&(*root)->left_node, nw_node); //If ITEM is greater that the ITEM in Root Node //Traverse the node in RIGHT - SIDE. else if(nw_node->i_data > (*root)->i_data) insert_node(&(*root)->right_node, nw_node); return false; } } void disp_tree(struct node *root) { //Check for NULL in LEFT - Node if(root->left_node) disp_tree(root->left_node); printf("\nNode- Left: %d \t Right: %d \t Item: %d\n", root>left_node, root->right_node, root->i_data); //Check for NULL in RIGHT - Node if(root->right_node) disp_tree(root->right_node); } int disp_menu(void) { printf("\n\n\n"); printf("\tTree Traversal: In-Order - 1\n"); printf("\tTree Traversal: Post-Order - 2\n"); printf("\tTree Traversal: Pre-Order - 3\n"); int i_choice; printf("\n\tPlease Enter your choice: "); scanf("%d", &i_choice); return i_choice; }
Saket Kr. Pathak
Page 85

void traverse_tree(int i_choice, struct node* root) { switch(i_choice) { case 1: inorder(root); break; case 2: postorder(root); break; case 3: preorder(root); break; } } void inorder(struct node *tree_node) { if (tree_node!=NULL) { inorder(tree_node->left_node); printf("\nData :%d",tree_node->i_data); inorder(tree_node->right_node); } } void preorder(struct node *tree_node) { if (tree_node!=NULL) { printf("\nData :%d",tree_node->i_data); preorder(tree_node->left_node); preorder(tree_node->right_node); } } void postorder(struct node *tree_node) { if (tree_node!=NULL) { postorder(tree_node->left_node); postorder(tree_node->right_node); printf("\nData :%d",tree_node->i_data); } } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~ Saket Kr. Pathak Page 86
7. WAP in C for Graph Traversal Breadth First Search Depth First Search Program: Breadth First Search: Algorithm [1] Enqueue the root node. [2] Dequeue a node and examine it a. If the element sought is found in this node, quit the search and return a result. b. Otherwise enqueue any successors (the direct child nodes) that have not yet been discovered. [3] If the queue is empty, every node on the graph has been examined quit the search and return "not found". [4] If the queue is not empty, repeat from Step 2 Time Complexity The total time for initializing is O (n) and the total time for the queuing operations is O (n) because each node is put on the queue exactly once. The total time in the main loop is O (e) because we look at each edge at most twice, once from each direction. This gives a time complexity of O (n + e). Code Snippet: #include <stdio.h> #include <stdlib.h> #include <stdbool.h> int int int int int **i_adjacency_matrix; *i_nodes_visit; *i_bfs_path; i_no_nodes; flag, n_flag = -1; get_graph_input(void); initialize_nodes(void); breadth_first_search(void); check_node(int); Page 87
bool bool void void
Saket Kr. Pathak

int main() { printf("\n\n\n"); printf("\t\t\tWAP for Graph Traversal (Depth First Search)."); printf("\n\n\n"); bool b_check; b_check = get_graph_input(); if (b_check) b_check = initialize_nodes(); printf("\n\n\n"); printf("Depth First Path within the given graph:\n"); breadth_first_search(); printf("\n\n\n"); system("pause"); return 0; } bool get_graph_input(void) { printf("Enter Number of Nodes: "); scanf("%d", &i_no_nodes); i_adjacency_matrix = malloc(sizeof(int) * i_no_nodes); i_nodes_visit = malloc(sizeof(int) * i_no_nodes); i_bfs_path = malloc(sizeof(int) * i_no_nodes); int i_temp = 0; int i_count, j_count; for (i_count = 0; i_count < i_no_nodes; ++i_count) { *(i_adjacency_matrix + i_count) = (int*)malloc(sizeof(int) * i_no_nodes); for (j_count = 0; j_count < i_no_nodes; ++j_count) { printf("\nConection of node %d to node %d is: ", i_count, j_count); scanf("%d", &i_temp); if ((i_temp == 1)||(i_temp == 0)) i_adjacency_matrix[i_count][j_count] = i_temp; else { printf("Input is invalid."); Saket Kr. Pathak Page 88

return false; } } } printf("\n\n\nAdjacency Matrix, so formed:"); for (i_count = 0; i_count < i_no_nodes; ++i_count) { printf("\n"); for (j_count = 0; j_count < i_no_nodes; ++j_count) printf("\t%d", i_adjacency_matrix[i_count][j_count]); } return true; } bool initialize_nodes(void) { int i_count; for (i_count = 0; i_count < i_no_nodes; ++i_count) i_nodes_visit[i_count] = 0; return true; } void breadth_first_search(void) { int i_count; int i_start_node; printf("\n\tPlease Enter Starting Node: "); scanf("%d", &i_start_node); check_node(i_start_node); for (i_count = 1; i_count <= i_no_nodes; ++i_count) if (i_nodes_visit[i_count]) printf("%d\t",i_count); else printf("\n Bfs is not possible"); } void check_node(int i_start_node) { int i_count;
Saket Kr. Pathak
Page 89

for (i_count = 0; i_count <= i_no_nodes; ++i_count) if ((i_adjacency_matrix[i_start_node][i_count]) && (!i_nodes_visit[i_count])) i_bfs_path[++n_flag] = i_count; if (flag <= n_flag) { i_nodes_visit[i_bfs_path[flag]] = 1; check_node(i_bfs_path[flag++]); } return; } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~ Depth First Search: Algorithm [1] If the initial state is a goal state, quit and return success. [2] Otherwise, loop until success or failure is signaled. Generate a state, say E, and let it be the successor of the initial state. If there is no successor, signal failure. Call Depth-First Search with E as the initial state. If success is returned, signal success. Otherwise continue in this loop. Time Complexity The time complexity is O (E + V). Code Snippet: #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define MAX_NUM_NODES 1024
int **i_adjacency_matrix; int *i_nodes_visit; int i_no_nodes; bool get_graph_input(void); Saket Kr. Pathak Page 90

bool initialize_nodes(void); void depth_first_search(void); void check_node(int); int main() { printf("\n\n\n"); printf("\t\t\tWAP for Graph Traversal (Depth First Search)."); printf("\n\n\n"); bool b_check; b_check = get_graph_input(); if (b_check) b_check = initialize_nodes(); printf("\n\n\n"); printf("Depth First Path within the given graph:\n"); depth_first_search(); printf("\n\n\n"); system("pause"); return 0; } bool get_graph_input(void) { printf("Enter Number of Nodes: "); scanf("%d", &i_no_nodes); i_adjacency_matrix = malloc(sizeof(int) * i_no_nodes); i_nodes_visit = malloc(sizeof(int) * i_no_nodes); int i_temp = 0; int i_count, j_count; for (i_count = 0; i_count < i_no_nodes; ++i_count) { *(i_adjacency_matrix + i_count) = (int*)malloc(sizeof(int) * i_no_nodes); for (j_count = 0; j_count < i_no_nodes; ++j_count) { printf("\nConection of node %d to node %d is: ", i_count, j_count); scanf("%d", &i_temp); if ((i_temp == 1)||(i_temp == 0)) i_adjacency_matrix[i_count][j_count] = i_temp; Saket Kr. Pathak Page 91

else { printf("Input is invalid."); return false; } } } printf("\n\n\nAdjacency Matrix, so formed:"); for (i_count = 0; i_count < i_no_nodes; ++i_count) { printf("\n"); for (j_count = 0; j_count < i_no_nodes; ++j_count) printf("\t%d", i_adjacency_matrix[i_count][j_count]); } return true; } bool initialize_nodes(void) { int i_count; for (i_count = 0; i_count < i_no_nodes; ++i_count) i_nodes_visit[i_count] = 0; return true; } void depth_first_search(void) { int i_count; printf("\n\t"); for (i_count = 0; i_count < i_no_nodes; ++i_count) if(i_nodes_visit[i_count] == 0) check_node(i_count); } void check_node(int i_node) { int i_count; printf("Node(%d)\t", i_node); i_nodes_visit[i_node] = 1; for (i_count = 0; i_count < i_no_nodes; ++i_count) Saket Kr. Pathak Page 92

if (i_nodes_visit[i_count] == 0) check_node(i_count); return; } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~
Saket Kr. Pathak
Page 93

8. WAP in C for Minimum Cost Spanning Tree Program: Algorithm (Prims) [1] create a tree containing a single vertex, chosen arbitrarily from the graph [2] create a set containing all the edges in the graph [3] loop until every edge in the set connects two vertices in the tree remove from the set an edge with minimum weight that connects a vertex in the tree with a vertex not in the tree add that edge to the tree Time Complexity O (E * log (V)) where E is the number of edges and V is the number of vertices. Code Snippet: #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define MIN_COST 3000 int **i_adjacency_matrix; int *i_nodes_visit; int i_no_nodes; bool get_tree_input(void); int calc_cost_prims_algo(void); int main() { printf("\n\n\n"); printf("\t\t\tWAP for Minimum Cost Spanning Tree (Prim's algorithm)."); printf("\n\n\n"); bool b_check; b_check = get_tree_input(); int i_min_cost_spanning_tree = calc_cost_prims_algo(); printf("\n Minimun cost = %d", i_min_cost_spanning_tree); printf("\n\n\n"); Saket Kr. Pathak Page 94

system("pause"); return 0; } bool get_tree_input(void) { printf("Enter Number of Nodes: "); scanf("%d", &i_no_nodes); i_adjacency_matrix = malloc(sizeof(int) * i_no_nodes); i_nodes_visit = malloc(sizeof(int) * i_no_nodes); int i_temp = 0; int i_count, j_count; for (i_count = 0; i_count < i_no_nodes; ++i_count) { *(i_adjacency_matrix + i_count) = (int*)malloc(sizeof(int) * i_no_nodes); for (j_count = 0; j_count < i_no_nodes; ++j_count) { printf("\nCost of node %d to node %d is: ", i_count, j_count); scanf("%d", &i_temp); if ((i_temp != 0)) i_adjacency_matrix[i_count][j_count] = i_temp; else i_adjacency_matrix[i_count][j_count] = MIN_COST; } } printf("\n\n\nAdjacency Matrix, so formed:"); for (i_count = 0; i_count < i_no_nodes; ++i_count) { printf("\n"); for (j_count = 0; j_count < i_no_nodes; ++j_count) printf("\t%d", i_adjacency_matrix[i_count][j_count]); } return true; } int calc_cost_prims_algo(void) { int i_min_cost, i_total_cost; int i_count, j_count; Saket Kr. Pathak Page 95

int i_node_1, i_node_2; i_nodes_visit[0] = 1; int i_new_node = 0; while (i_new_node < i_no_nodes) { for (i_count = 0, i_min_cost = MIN_COST; i_count <= i_no_nodes; ++i_count) for (j_count = 0; j_count <= i_no_nodes; ++j_count) if ((i_adjacency_matrix[i_count][j_count] < i_min_cost) && (i_nodes_visit[i_count] != 0)) { i_min_cost = i_adjacency_matrix[i_count][j_count]; i_node_1 = i_count; i_node_2 = j_count; } if ((i_nodes_visit[i_node_1] == 0) || (i_nodes_visit[i_node_2] == 0)) { printf("\n Edge %d:(%d %d) cost:%d",i_new_node++, i_node_1, i_node_2, i_min_cost); i_total_cost += i_min_cost; i_nodes_visit[i_node_2] = 1; } i_adjacency_matrix[i_node_1][i_node_2] = i_adjacency_matrix[i_node_2][i_node_1] = MIN_COST; } return i_total_cost; } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~
Saket Kr. Pathak
Page 96

9. WAP in C for Shortest Path Problem Program: Algorithm (Dijkstras) [1] Assign to every node a tentative distance value: set it to zero for our initial node and to infinity for all other nodes. [2] Mark all nodes unvisited. Set the initial node as current. Create a set of the unvisited nodes called the unvisited set consisting of all the nodes except the initial node. [3] For the current node, consider all of its unvisited neighbors and calculate their tentative distances. [4] When we are done considering all of the neighbors of the current node, mark the current node as visited and remove it from the unvisited set. A visited node will never be checked again. [5] If the destination node has been marked visited (when planning a route between two specific nodes) or if the smallest tentative distance among the nodes in the unvisited set is infinity (when planning a complete traversal), then stop. The algorithm has finished. [6] Select the unvisited node that is marked with the smallest tentative distance, and set it as the new "current node" then go back to step 3. Time Complexity Time complexity of the following algorithm is O (M * log (N)), where M is number of edges and N is number of vertices. Code Snippet: #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define UNDEFINED_COST 3000 int **i_adjacency_matrix; int *i_nodes_visit; int i_no_nodes; int get_tree_input(void); void calc_cost_Dijkstra_algo(int); int main() { Saket Kr. Pathak Page 97

printf("\n\n\n"); printf("\t\t\tWAP for Shortest Path Problem (Dijkstra's algorithm)."); printf("\n\n\n"); int i_source; i_source = get_tree_input(); calc_cost_Dijkstra_algo(i_source); printf("\n\n\n"); system("pause"); return 0; } int get_tree_input(void) { printf("Enter Number of Nodes: "); scanf("%d", &i_no_nodes); i_adjacency_matrix = malloc(sizeof(int) * i_no_nodes); i_nodes_visit = malloc(sizeof(int) * i_no_nodes); int i_temp = 0; int i_count, j_count; for (i_count = 0; i_count < i_no_nodes; ++i_count) { *(i_adjacency_matrix + i_count) = (int*)malloc(sizeof(int) * i_no_nodes); for (j_count = 0; j_count < i_no_nodes; ++j_count) { printf("\nCost of node %d to node %d is: ", i_count, j_count); scanf("%d", &i_temp); if ((i_temp != 0)) i_adjacency_matrix[i_count][j_count] = i_temp; else i_adjacency_matrix[i_count][j_count] = UNDEFINED_COST; } } printf("\n\n\nAdjacency Matrix, so formed:"); for (i_count = 0; i_count < i_no_nodes; ++i_count) { printf("\n"); for (j_count = 0; j_count < i_no_nodes; ++j_count) Saket Kr. Pathak Page 98

printf("\t%d", i_adjacency_matrix[i_count][j_count]); } int i_source_node; printf("\nEnter the source node: "); scanf("%d", &i_source_node); return i_source_node; } void calc_cost_Dijkstra_algo(int i_source_node) { int i_count, j_count; int i_counter, i_flag; int i_init = 1; int flag[i_no_nodes]; i_nodes_visit[0] = 1; for (i_count = 0; i_count < i_no_nodes; ++i_count) { flag[i_count] = 0; i_nodes_visit[i_count] = i_adjacency_matrix[i_source_node][j_count]; } i_flag = 1; while (i_init < i_no_nodes) { int i_undef_cost = UNDEFINED_COST; for (i_count = 0; i_count < i_no_nodes; ++i_count) { if ((i_nodes_visit[i_count] < i_undef_cost) && (!flag[i_count])) { i_undef_cost = i_nodes_visit[i_count]; i_counter = i_count; } flag[i_counter] = 1; i_flag++; for (i_count = 0; i_count < i_no_nodes; ++i_count) if ((i_nodes_visit[i_counter] + i_adjacency_matrix[i_counter][i_count] < i_nodes_visit[i_count]) && (!flag[i_count])) Saket Kr. Pathak Page 99

i_nodes_visit[i_count] = i_nodes_visit[i_counter] + i_adjacency_matrix[i_counter][i_count]; } } printf("\n Shortest path so obtained :\n"); for (i_count = 0; i_count < i_no_nodes; ++i_count) if (i_count != i_source_node) printf("Source: %d to %d,cost=%d\n",i_source_node, i_count, i_nodes_visit[i_count]); } ~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~
Saket Kr. Pathak
Page 100

Data Structure in C (Lab Programs)

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Data Structure in C (Lab Programs)

Uploaded by

Copyright:

Available Formats

2013

Saket Kr. Pathak Software Developer 3D Graphics

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Saket Kr. Pathak

Data Structure in C (Lab. Programs)

Saket Kr. Pathak

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Saket Kr. Pathak

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Saket Kr. Pathak

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Saket Kr. Pathak

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Saket Kr. Pathak

Data Structure in C (Lab. Programs)

Saket Kr. Pathak

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Saket Kr. Pathak

Data Structure in C (Lab. Programs)

Saket Kr. Pathak

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)

Data Structure in C (Lab. Programs)