data structure in c (lab programs)

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.

2013

Saket Kr. Pathak Software Developer 3D Graphics

Data Structure in C (Lab. Programs)

Content (Programs List)

S. No. Subject Date Sign Remark1. WAP in C for following Sorting Methods

Bubble Sort Merge Sort Insertion Sort Selection Sort Quick Sort

2. WAP in C for following Searching Methods Linear Search Binary Search

3. WAP in C for array implementation of Stack Queue Circular Queue Linked List

4. WAP in C using dynamic memory allocation of Stack Queue Circular Queue Linked List

5. WAP in C for implementation of Binary Tree.

6. WAP in C for Tree Traversal Pre-Order In-Order Post-Order

7. WAP in C for Graph Traversal Breadth First Search Depth First Search

8. WAP in C for Minimum Cost Spanning Tree

9. WAP in C for Shortest Path Problem

Saket Kr. Pathak


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: O (n) timeAverage case: O (n2) timeWorst case: O (n2) time

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);

Saket Kr. Pathak


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


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: O (n * log (n)) timeAverage case: O (n * log (n)) timeWorst case: O (n * log (n)) time

Code – Snippet:

#include<stdio.h>#include<stdbool.h> #define ARRAY_SIZE 1024

Saket Kr. Pathak


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


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 storage[k]=temp_arr_2[j++];

Saket Kr. Pathak


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


[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: O (n) timeAverage case: O (n2) timeWorst case: O (n2) time

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;}

Saket Kr. Pathak


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* 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) {

Saket Kr. Pathak


printf("%d", i_store[i_ndx]); 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: O (n2) timeAverage case: O (n2) timeWorst case: O (n2) time

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);

Saket Kr. Pathak


int* ip_store = get_elem(i_store_size); ip_store = selection_sort(ip_store, i_store_size); disp_elem(ip_store, i_store_size); printf("\n\n\n"); system("pause"); return 0;}


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)

Saket Kr. Pathak


{ printf("\nDisplaying Elements of store: "); int i_ndx = 0; 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: O (n * log (n)) timeAverage case: O (n * log (n)) timeWorst case: O (n2) time

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);

Saket Kr. Pathak


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); printf("\n\n\n"); system("pause"); return 0;}


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; }

Saket Kr. Pathak


if (i_begin < i_finish) { i_temp = i_store[i_begin]; 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


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 key’s phone number matches D, or -1

if not found

Time Complexity –

Best case: O (1) timeAverage case: O (n) timeWorst case: O (n) time

Code – Snippet:

#include <stdio.h>#include <stdlib.h>#include <string.h>#include <stdbool.h>#include <math.h>

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;

Saket Kr. Pathak


} } if (!b_flag) 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


}

~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~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: O (1) timeAverage case: O (log (n)) timeWorst case: O (n) time

Code – Snippet:

#include <stdio.h>#include <stdlib.h>#include <string.h>#include <stdbool.h>#include <math.h>

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);

Saket Kr. Pathak


}else if(i_storage[i_mid] > i_srch_item){

i_hi = i_mid;i_mid = (i_low + i_hi)/2;

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");

Saket Kr. Pathak


}

void binary_search(void){

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();


}

~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~

Saket Kr. Pathak


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 Push Item: \t\t(Press) 1");printf("\n\tTo Pop Item: \t\t(Press) 2");printf("\n\tTo Display Item: \t(Press) 3");printf("\n\tTo 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;

elsereturn 0;

}

int push_item(int i_item){

Saket Kr. Pathak


if(i_top == (STACK_SIZE - 1)){

printf("\n\tStack Overflow.");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)

Saket Kr. Pathak


{printf("\n\tStack is Empty.");return 0;

}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;

}}

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;

}

Saket Kr. Pathak


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 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 {

Saket Kr. Pathak


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);

}


}

~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~

Queue:

Code – Snippet:


#define QUEUE_SIZE 1024

int i_front = -1;int i_rear = -1;int queue[QUEUE_SIZE];

int main(){



int i_state;do{

i_state = process_stack(i_check);i_check = set_Argument();

Saket Kr. Pathak


if(i_check == 4) //Check for Exit.


}


}


printf("\n\t--------------------------------------------------\n");




;

return i_check;}



}



elsereturn 0;

}

Saket Kr. Pathak



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


}}


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);


return 1;}

}

Saket Kr. Pathak



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;

}}


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

Saket Kr. Pathak


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:{


}default:{

return 0;break;

}}

}

~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~

Circular Queue:

Code – Snippet:



int i_front = -1;int i_rear = -1;int circular_queue[QUEUE_SIZE];


Saket Kr. Pathak



}



elsereturn 0;

}


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


}}


if(i_front == -1){

Saket Kr. Pathak



}else{


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);


return 1;}

}


if((i_front == -1) || (i_front == i_rear + 1)){


}else{


printf("\n\tIndex: %d | Item: %d", i_count, circular_queue[i_count]);

}return 1;

}}

Saket Kr. Pathak



switch(i_choice){

case 1:{


return 1;else

return 0;break;

}case 2:{


return 1;else

return 0;break;

}case 3:{


return 1;else

return 0;break;

}case 4:{


}

Saket Kr. Pathak


default:{

return 0;break;

}}

}


printf("\n\t--------------------------------------------------\n");




;

return i_check;}

int main(){



int i_state;do{



}


}

Saket Kr. Pathak


~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~

Linked List:

Code – Snippet: (Singly Linked List)


#define LINKED_LIST_SIZE 1024

int set_argument(void);int select_choice(void);int process_stack(int i_choice);int push_node(int i_item, int i_indx);int disp_node(void);int 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.


}

Saket Kr. Pathak


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\



;

return i_check;}



}



elsereturn 0;

}


switch(i_choice){

case 1:{

printf("\n\tTo Push Item into Linked-List.\n");

Saket Kr. Pathak


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;

elsereturn 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:{


}default:

Saket Kr. Pathak


{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---------------------------");


elsereturn 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;

Saket Kr. Pathak


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; } } 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;

Saket Kr. Pathak


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; } else

Saket Kr. Pathak


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)




struct node

Saket Kr. Pathak


{ int i_prev_idx; int i_val; int i_next_idx;}ll_node[LINKED_LIST_SIZE];

int i_ll_size = 0;



else {

int i_state;do{



}


return 0;}


printf("\n\t--------------------------------------------------\n");




;

return i_check;}

Saket Kr. Pathak




}



elsereturn 0;

}


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:{



else

Saket Kr. Pathak


; } i_check = pop_node(i_check);


elsereturn 0;

break;}case 3:{


return 1;else

return 0;break;

}case 4:{


}default:{

return 0;break;

}}

}



}


printf("\n\t\t---------------------------");

Saket Kr. Pathak



elsereturn 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; 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++; }

Saket Kr. Pathak


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; 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

Saket Kr. Pathak


{ 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; //------------- } return 1; } else return 0;}

int disp_node(void){

Saket Kr. Pathak


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


4. WAP in C using dynamic memory allocation of Stack Queue Circular Queue Linked List

Program:

Stack:

Code – Snippet:


#define STACK_SIZE 1024

int i_top = -1;int *stack;

int main(){



int i_state;stack = (int*)malloc(sizeof(int) * STACK_SIZE);

do{

i_state = process_stack(i_check);i_check = set_Argument();

Saket Kr. Pathak


if(i_check == 4) //Check for Exit.


}


}


printf("\n\t--------------------------------------------------\n");




;

return i_check;}



}



elsereturn 0;

}

Saket Kr. Pathak



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;else

return 0;break;

}case 4:{


}default:

Saket Kr. Pathak


{return 0;break;

}}

}


if(i_top == (STACK_SIZE - 1)){

printf("\n\tStack Overflow.");return 0;

}else{

*(stack + (++i_top)) = i_item;printf("\n\tItem - %d, has successfully pushed into


}}


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));}

}

Saket Kr. Pathak


i_top = (i_count - 2);//Substracting: 2 = (additional loop increment + 1 deleted

item) return 1;

}}


if(i_top == -1){

printf("\n\tStack is Empty.");return 0;

}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:



int i_front = -1;int i_rear = -1;int *queue;

int main()

Saket Kr. Pathak


{int i_check = set_Argument();if(i_check == 0)


int i_state;queue = (int*)malloc(sizeof(int) * QUEUE_SIZE);

do{



}


}


printf("\n\t--------------------------------------------------\n");




;

return i_check;}



Saket Kr. Pathak


}



elsereturn 0;

}


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


}}


if((i_front == -1)||(i_front > i_rear)){


}else{


if((*(queue + i_count) == i_item)&&(!b_flag)){

*(queue + i_count) = *(queue + (i_count+1));b_flag = true;

}

Saket Kr. Pathak


else if(b_flag){

*(queue + i_count) = *(queue + (i_count+1));}

}i_rear = (i_count - 2);


return 1;}

}


if(i_front == -1){


}else{


printf("\n\tIndex: %d | Item: %d", i_count, *(queue + i_count));

}return 1;

}}


switch(i_choice){

case 1:{


return 1;else

return 0;

Saket Kr. Pathak


break;}case 2:{


return 1;else

return 0;break;

}case 3:{


return 1;else

return 0;break;

}case 4:{


}default:{

return 0;break;

}}

}

~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~

Circular Queue:

Code – Snippet:

Saket Kr. Pathak




int i_front = -1;int i_rear = -1;int *circular_queue;

int main(){



int i_state;circular_queue = (int*)malloc(sizeof(int) *

QUEUE_SIZE);do{



}


}


printf("\n\t--------------------------------------------------\n");




;

Saket Kr. Pathak


return i_check;}



}



elsereturn 0;

}


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


}

Saket Kr. Pathak


}


if(i_front == -1){


}else{


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);


return 1;}

}


if((i_front == -1) || (i_front == i_rear + 1)){


}else{

printf("\n\tElements of Queue are:");int i_count;for(i_count = i_front; i_count <= i_rear; ++i_count)

Saket Kr. Pathak


{printf("\n\tIndex: %d | Item: %d", i_count,

*(circular_queue + i_count));}return 1;

}}


switch(i_choice){

case 1:{


return 1;else

return 0;break;

}case 2:{


return 1;else

return 0;break;

}case 3:{


return 1;else

return 0;break;

Saket Kr. Pathak


}case 4:{


}default:{

return 0;break;

}}

}~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~

~~~Linked List:

Code – Snippet: (Singly Linked List)




struct node{ int i_val; int i_next_idx;}*ll_node;

int i_ll_size = 0;



else {

Saket Kr. Pathak


int i_state;ll_node = (struct node*)malloc(sizeof(int) *

LINKED_LIST_SIZE);do{



}


return 0;}


printf("\n\t--------------------------------------------------\n");




;

return i_check;}



}


Saket Kr. Pathak



elsereturn 0;

}


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:{





elsereturn 0;

break;}case 3:{

printf("\n\tTo Display Item of Queue.");int i_check = disp_node();

Saket Kr. Pathak



elsereturn 0;

break;}case 4:{


}default:{

return 0;break;

}}

}



}


printf("\n\t\t---------------------------");


elsereturn 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);

Saket Kr. Pathak


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) { 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: ");

Saket Kr. Pathak


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


}

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; ) { 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;}

Saket Kr. Pathak


~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~

Code – Snippet: (Doubly Linked List)




struct node{ int i_prev_idx; int i_val; int i_next_idx;}*ll_node;

int i_ll_size = 0;



else {

int i_state;ll_node = (struct node*)malloc(sizeof(int) *

LINKED_LIST_SIZE);do{



}

Saket Kr. Pathak



return 0;}


printf("\n\t--------------------------------------------------\n");




;

return i_check;}



}



elsereturn 0;

}


switch(i_choice){

case 1:{

printf("\n\tTo Push Item into Linked-List.\n");

Saket Kr. Pathak


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:{





elsereturn 0;

break;}case 3:{


return 1;else

return 0;break;

}case 4:{


}default:

Saket Kr. Pathak


{return 0;break;

}}

}



}


printf("\n\t\t---------------------------");


elsereturn 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) {

Saket Kr. Pathak


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) { 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; ) {

Saket Kr. Pathak


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;}

int push_node(int i_item, int i_indx){ if (i_indx < (LINKED_LIST_SIZE-1)) { if (i_ll_size == 0) {

Saket Kr. Pathak


(*(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); 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;

Saket Kr. Pathak


} return 1;}

~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~

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");

Saket Kr. Pathak


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){ 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;

Saket Kr. Pathak


}

bool insert_node(struct node **root, struct node *nw_node){

//Check for Null Root-Nodeif(!(*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.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 - Nodeif(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 - Nodeif(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;

Saket Kr. Pathak


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; } 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

Saket Kr. Pathak


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) { 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

Saket Kr. Pathak


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); 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)

Saket Kr. Pathak


{ 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;

} 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)

Saket Kr. Pathak


{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;}

} } } }

return current_node;}

~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~

Saket Kr. Pathak


6. WAP in C for Tree Traversal Pre-Order In-Order Post-Order

Program:

Code – Snippet:


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);

Saket Kr. Pathak


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"); 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;

Saket Kr. Pathak


}

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-Nodeif(!(*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.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 - Nodeif(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);

Saket Kr. Pathak


//Check for NULL in RIGHT - Nodeif(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;}

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)

Saket Kr. Pathak


{ 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); }}

~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~

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 –

Saket Kr. Pathak


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:


int **i_adjacency_matrix;int *i_nodes_visit;int *i_bfs_path;int i_no_nodes;int flag, n_flag = -1;

bool get_graph_input(void);bool initialize_nodes(void);void breadth_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"); breadth_first_search(); printf("\n\n\n"); system("pause"); return 0;}

bool get_graph_input(void){

Saket Kr. Pathak


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."); 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;

Saket Kr. Pathak


}

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; 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.

Saket Kr. Pathak


[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:


#define MAX_NUM_NODES 1024

int **i_adjacency_matrix;int *i_nodes_visit;int i_no_nodes;

bool get_graph_input(void);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");

Saket Kr. Pathak


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; 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;

Saket Kr. Pathak


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) if (i_nodes_visit[i_count] == 0) check_node(i_count);

return;}

~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~

Saket Kr. Pathak


8. WAP in C for Minimum Cost Spanning Tree

Program:

Algorithm (Prim’s) –

[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>

Saket Kr. Pathak


#include <stdlib.h>#include <stdbool.h>

#define MIN_COST 3000


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"); 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) {

Saket Kr. Pathak


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; 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)) {

Saket Kr. Pathak


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;}

~~~~~~~~~~~~~~~~~~~~~************~~~~~~~~~~~~~~~~~~~~~

9. WAP in C for Shortest Path Problem

Program:

Algorithm (Dijkstra’s) –

[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

Saket Kr. Pathak


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:


#define UNDEFINED_COST 3000


int get_tree_input(void);void calc_cost_Dijkstra_algo(int);

int main(){ 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){

Saket Kr. Pathak


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) 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];

Saket Kr. Pathak


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])) 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


Saket Kr. Pathak

data structure in c (lab programs)

Education

store i

count i

size int i

elemint i

sortint i

temp int i

programsint i

printfnnn int i