Data Structures Using C (CS-211

)

S.Y.B.Sc.(Computer Science)

Semester I
Authors: Prof. Mrs. Madhuri Ghanekar Prof. Mrs. A. S. Bachav Prof. Mrs. Smita Ghorpade Prof. Mrs. G. S. Marane Prof. Mrs. Sonali Ghule

1

Table of Contents About the work book……………………………………………………………3 1. Sorting Techniques……………………………………………………………5 2. Searching Techniques………………………………………………………...11 3. Linked List……………………………………………………………………...14 4. Stack……..………………………………………………………………………28 5. Queue..………..…………………………………………………………………33 6. Trees....…………………………………………………………………………...40 7.Graph...…………………………………………………………………………...46

2

About the Work Book
Objectives of this book This workbook is intended to be used by S.Y.B.Sc(Computer Science) students for the two computer science laboratory courses. The objectives of this book are 1. The scope of the course. 2. Bringing uniformity in the way course is conducted across different colleges. 3. Continuous assessment of the students. 4. Providing ready references for students while working in the lab. How to use this book? This book is mandatory for the completion of the laboratory course. It is a measure of the performance of the student in the laboratory for the entire duration of the course. Instructions to the students 1) 2) 3) 4) Students should carry this book during practical sessions of computer science. Students should maintain separate journal for the source code, SQL queries/commands along with outputs. Student should read the topics mentioned in Reading section of this book before coming for practical. Students should solve only those exercises which are selected by practical in-charge as a part of journal activity. However, students are free to solve additional exercises to do more practice for their practical examination. Difficulty Level NA Easy Medium Difficult Rule Student should solve these exercises for practice only. All exercises are compulsory. At least one exercise is mandatory. Not Compulsory.

Exercise Set Self Activity SET A SET B SET C 5)

Students will be assessed for each exercise on a scale of 5 1. Note Done 2. Incomplete 3.Late Complete 4.Needs Improvement 5.Complete 6.Well Done 0 1 2 3 4 5 3

Instructions to the Practical In-charge 1) 2) 3) 4) 5) 6) Explain the assignment and related concepts in around ten minutes using white board if required or by demonstrating the software. Choose appropriate problems to be solved by student. After a student completes a specific set, the instructor has to verify the outputs and sign in the provided space after the activity. Ensure that the students use good programming practices. You should evaluate each assignment carried out by a student on a scale of 5 as specified above ticking appropriate box. The value should also be entered on assignment completion page of respected lab course.

4

SESSION 1: Sorting Techniques
Objectives

Start Date ___/____/______

To learn about: Sorting array elements in increasing/decreasing order Various sorting methods and their time complexity Searching methods and their time complexity Reading You should read the following topics before starting the exercise. 1. Numeric / Character arrays and Array of structures. 2. Compare the one element with another element of the array 3. Swap the content of one location with another location in the array. 4. How to find the time complexity of an algorithm? Ready References 1.1 Time complexity The time T(P) taken by a program P is the sum of the compile time and the run (or execution) time. As compilation is a one time procedure, we approximate time complexity to execution time.For this we calculate the number of executable steps of any program which can be stored in a variable stepcnt. Algorithm Sum(a,n) 1 { 2 S= 0.0; 3 Stepcnt = stepcnt +1; 4 For i = 1 to n do 5 { 6 Stepcnt=stepcnt+1; 7 S = S + a[i]; 8 Stepcnt = stepcnt +1; 9 } 10 Stepcnt = stepcnt +1; 11 Stepcnt = stepcnt +1; 12 Return S; 13 } Comments Stepcnt is initially zero. For the execution of for statement increment it once. Increment for the assignment statement For the last invocation of for For the return

Important operations for sorting and searching algorithms are as follows: 1. Number of interchanges/swaps 2. Number of comparisons As these 2 operations are more time consuming, for sorting and searching algorithms swapcnt and compcnt is calculated to find number of swaps and number of comparisons along with the stepcnt. 5

Program Segment for (i=0; i< n; i++) { stepcnt ++; compcnt++; if ( x[i] > x[j] ) { compcnt++; swapcnt++; temp = x[i]; x[i] = x[j]; x[j] = x[i]; stepcnt +=4; }

Comments Checking i< n so compcnt++ Comparing 2 elements So compcnt++ Swapping of 2 elements So swapcnt ++ Total 4 steps . so stepcnt += 4

1.2 Sorting Techniques Most of the applications store lots of data and to find the required data from it, we must keep it in some sensible order. The sorting refers to the operation of arranging data in some given order, such as increasing or decreasing, with numerical or character data. There are various sorting methods are available. Most commonly used methods are (1) Bubble Sort (2)Insertion Sort (3)Merge Sort (4)Quick Sort 1.2.1 Bubble Sort In this method successive elements are compared and exchange according to the order required. The list to be sorted is traversed several times. Each pass puts one element in its correct position. In successive parses, the largest element sinks to the bottom. 1. 2. 3. 4. 5. 6. 7. 8. Algorithm Accept n numbers into the array x Initialize i=0 Repeat step 4 to 7 as long as (i<n) if (x[j]>x[j+1]) interchange x[j] and x[j+1] Increment j if j<n-1-j got step 3 Increment i stop Complexity The number of passes: n-1 In first pass n-1 comparisons In second pass n-2 comparisons and so on Total=(n-1)+(n-2)+……+1= n(n1)/2 Time Complexity=O(n2) Best case= O(n2) Worst case= O(n2) 92 12 37 48 48 48 12 37 57 57 57 57 37 92 92 92 92 92

Example: Original array x After Pass 1 After Pass 2 After Pass 3 After Pass 4 After Pass 5

57 25 25 25 12 12

25 48 48 12 25 25

48 57 12 37 37 37

6

1.2.2 Insertion Sort Place an element into correct position in growing sorted list of data. Assume that we have a sorted list of i elements. We take the next element and add it to the sorted list in such a position that a new list of (i+1) elements is sorted. Algorithm 1. Accept n numbers into the array x 2. Let x[0] is sorted list of one element. 3. Let j=1 4. Let newelem=x[j] and i=j-1 5. Repeat step 6 to 7 as long as (i>=0) and (newelem<x[i]) 6. Move x[i] at (i+1) position 7. i=i-1 8. Insert newelem at position (i+1) i.e. x[i+1]=newelem 9. j=j+1 10. If j<n go to step 4 11. stop Example: Let x[0] is sorted list: Pass-1: newelem=25: Pass-2: newelem=48: Pass-3: newelem=57: Pass-4: newelem=12: 57 25 25 25 25 25 25 12 12 12 12 25 57 48 48 48 48 25 25 25 25 25 48 48 57 57 57 48 48 48 48 48 36 Complexity Best case: If the initial data is sorted, only one comparison is made in each pass. So the complexity is O(n). Worst case: If the initial data is in reverse order, total number of comparisons for (n-1) passes will be 1+2+3+……+(n-1)=n(n-1)/2 So the complexity is O(n2)

Pass-5: newelem=36:

1.2.3 Merge Sort It is based on Divide and Conquer Strategy. First the list to be sorted is decomposed into two sublists(Divide). Each sublist is sorted independently(Conquer). Then these two sorted sublists are merged into sorted sequence(Combine).

12 12 12 12 57 57 57 57 57 48 48

36 36 36 36 36 36 36 36 57 57 57

7

Algorithm //Array x of size n is to be sorted, Initially lb=0, ub=n-1 Mergesort(x, lb, ub) 1. If (lb<ub) do steps 2 to 5 otherwise goto 6 2. Find mid=(lb+ub)/2 3. call mergesort(lb, mid) 4. call mergesort(mid+1, ub) 5. call merge(x, lb, mid, ub) 6. stop //Merge two sorted sublists x[lb..mid] and x[mid+1..ub] to create a new sorted list x[lb…ub] Merge(x. lb, mid, ub) 1. //copy x into temp list For i=lb to ub do temp[i]=x[i] 2. Let i=lb, j=mid+1, k=lb 3. Repeat steps 4 to 6 while (i<=mid and j<=ub) 4. If (temp[i]<=temp[j]) //elem of first sublist is smaller/equal x[k]=temp[i] //copy elem of first sublist Increment i and k 5. Otherwise //elem of second sublist is smaller x[k]=temp[j] //copy elem of second sublist Increment j and k 6. Continue step 3 7. Copy remaining elements of first sublist into x if any 8. Copy remaining elements of second sublist into x if any 9. stop

Complexity After pass P, the array x is partitioned into sorted subarrays where subarray, except possibly the last, will contain exactly 2P elements. Hence the algorithm requires at most log2 n passes to sort n elements of array x. However each pass merges a total of n elements. So time complexity, Best Case: O(n log n) Worst Case: O(n log n)

8

Example: Original array:

[66

33

40

22

55

88

60

11]

Pass-1: Merge each pair of elements to obtain the list of sorted pairs [66 33 40 22 55 88 60 11]

[33 66]

[22 40]

[55 88]

[11 60]

Pass-2: Merge each pair of pairs to obtain the list of sorted quadruples [33 66] [22 40] [55 88] [11 55 60 88] [11 60]

[22 33 40 60]

Pass-3: Merge each pair of sorted quadruples to obtain the sorted array [11 22 33 40 55 60 88]

1.2.4 Quick Sort It is also based on Divide and Conquer Strategy. Let x be an array and n be number of elements in the array to be sorted. To find proper position j for any element a of array x, it is partitioned at position j such that (I) All elements from 0 to j-1 are smaller than or equal to a (II) All elements from j+1 to n-1 are greater than a. Algorithm //sort array x[lb..ub]. Initially lb=0 and ub=n-1 QuickSort(x, lb, ub) // x is array 1. If (lb<ub) do steps 2 to 8 otherwise goto 9 2. Let i=lb, j=ub, a=x[i] //to find posi for a 3. Repeat step 4 while (x[j]>a && j>i) 4. decrement j 5. Interchange x[i] and x[j] 6. Repeat step 7 while (x[i]<=a && i<j) 7. increment i 8. Interchange x[i] and x[j] 9. quicksort(x, lb, i-1) //recursive call to sublist 10. quicksort(x, i+1, ub)//recursive call to sublist 11. Stop Complexity Best case: The reduction step produces two sublists. The reduction step in the kth level there will be 2k sublists. Each level uses at most n comparisons. So the time complexity is O(n log n) Worst case: If the list is already sorted then at first level, first list is empty and second list contains (n-1) elements. Accordingly the second element require (n-1) comparisons and so on. So the total comparisons are n+(n-1)+…+2+1= n(n+1)/2 The time complexity is O(n2)

9

Practical Assignments SET A 1) Write a C program to read n numbers from the user and sort them in ascending/ descending order using Bubble sort method. Use step count, swap count, comp count in your program to calculate time complexity and at end display the 3 counts 2) Write a C program to read n numbers from the user and sort them in ascending/descending order using Insertion sort method. Use step count, swap count, comp count in your program to calculate time complexity. SET B 1) Write a C program to read n numbers from the user and sort them in ascending/ descending order using Merge sort. Use step count, swap count, comp count in your program to calculate time complexity. 2) Write a C program to read n numbers from the user and sort them in ascending/ descending order using Quick sort. Use step count, swap count, comp count in your program to calculate time complexity. SET C 1) Write a program that accept name of persons into array and sort them in alphabetical order. 2) Write a program that accept employee name, age and salary into array and sort them in descending order of salary. [ Hint: Use array of structure] Assignment Evaluation 0: Not Done [ ] 3:Needs Improvement [ ] 1:Incomplete [ ] 4:Complete [ ] 2.Late Complete [ ] 5:Well Done [ ]

Signature of the Instructor

Date of Completion ____/____/______ End of Session 10

SESSION 2: Searching Techniques
Objectives

Start Date ___/____/______

To learn about: Searching a desired element in the array Various searching methods and their time complexity Reading You should read the following topics before starting the exercise. 1. Numeric / Character arrays and Array of structures. 2. Compare an element with any element of the array 3. Sorting the content of array in ascending or descending order 4. How to find the time complexity of an algorithm? Ready References Let LIST be a collection of data elements into memory. Searching refers to the operation of finding the location of given ITEM in LIST. The searching said to be successful, if ITEM is found in LIST and unsuccessful otherwise. There are two commonly used searching methods or algorithms (1) Linear Search (2) Binary Search 2.1. Linear Search In this method ITEM is compare with each element of LIST one by one. That is, first we test whether LIST[0] = ITEM and then we test whether LIST[1]=ITEM and so on. This method which traverses LIST sequentially to locate ITEM is called Linear or Sequential search. Algorithm //Linear Search ITEM in LIST of n elements 1. LOC=0 2. Repeat steps 3 to 4 while (LOC<n) 3. If (LIST[LOC]=ITEM) print ITEM found at location LOC stop 4. Otherwise increment LOC by 1 continue step 2 5. print ITEM not found in LIST 6. Stop Complexity Best Case: ITEM found at location 1 Number of comparisons=1 Worst Case: ITEM not found in LIST Number of comparisons=n Complexity is O(n) An average of (n+1)/2 comparisons are required to search ITEM in a LIST. Time complexity is O(n)

11

2.2. Binary Search If the collection elements in a LIST is stored in sorted order (ascending or descending) then there is extremely efficient searching algorithm called Binary Search is available. In this method LIST is divided into two halves. The ITEM to be search is compare with middle element of the LIST. If matches then search terminates otherwise continues further. If the ITEM is less than middle element then the search proceeds in upper half of the LIST. If the ITEM is greater than middle element then the search proceed in lower half of the LIST. Algorithm //Binary Search ITEM in LIST of n elements //LB-Lower Bound UB-Upper Bound of LIST Recursive Bsearch(LIST, ITEM, LB, UB) 1. If (LB>UB) Print ITEM not found in LIST Stop 2. Find MID=(LB+UB)/2 3. If (LIST[MID]=ITEM) Print ITEM found at location MID in LIST Stop 4. Otherwise If (LIST[MID]<ITEM) Bsearch(LIST, ITEM, LB, MID-1) //call 5. Otherwise 6. Bsearch(LIST, ITEM, MID+1, UB) //call Non-Recursive 1. Let LB=0, UB=n-1 2. Repeat steps 3 to 5 while (LB<UB) 3. Find MID=(LB+UB)/2 4. If (LIST[MID]=ITEM) Print ITEM found at location MID in LIST Stop 5. Otherwise If (LIST[MID]<ITEM) UB=MID-1 //search in upper half Continue step 2 6. Otherwise LB=MID+1 //search in lower half Continue step 2 7. Print ITEM not found in LIST 8. Stop Best Case: ITEM found at MID position Number of Comparisons=1 Worst Case: ITEM not found in LIST After 1 comparison, remaining size of LIST to be search is (n/2)=(n/21). After 2 comparisons, remaining size of LIST to be search is (n/4)=(n/22). After k comparisons, remaining size of LIST to be search is (n/2k). If after k comparisons, remaining file size is 1 then (n/2k)=1. That means n=2k k=log2 n So, time complexity is O(log2 n) Complexity

12

Practical Assignments SET A 1) Write a program to accept list of n numbers and search a given number using Linear Search. Use stepcnt, swapcnt, compcnt in your program to calculate time complexity and at end display the 3 counts 2) Write a program to accept list of cities and search a given city using Linear Search. Use stepcnt, swapcnt, compcnt in your program to calculate time complexity and at end display the 3 counts SET B 1) Write a program to accept list of sorted n numbers and search a given number using Binary Search. 2) Write a program to accept list of student names in alphabetical order and search a given name using Binary Search. SET C Accept city name, area and population for n cities into array. Find the area and population of given city using 1) Linear Search method 2) Binary Search method (Hint: Use array of structures and sort the array on city name before applying binary search) Assignment Evaluation 0: Not Done [ ] 3:Needs Improvement [ ] 1:Incomplete [ ] 4:Complete [ ] 2.Late Complete [ ] 5:Well Done [ ]

Signature of the Instructor

Date of Completion ____/____/______ End of Session

13

SESSION 3: Linked List
Objectives

Start Date ___/____/______

To learn about: Linked list implementation – dynamic and static. Types of linked lists - singly linked list, singly circular linked list, doubly linked list, doubly circular linked list. Reading You should read following topics before starting the exercise. static and dynamic variables limitations of Array pointers in C malloc() and free() functions in C Concept of linked list Ready References 3.1 Linked list Linked list is a collection of nodes. These nodes are nothing but dynamic variables. These dynamic variables are allocated memory from heap space. All the nodes present in the linked list are not stored in contiguous memory location hence every node of the linked list contains data(info) and pointer to the next node called as link.

Head

Info link

10

20

30

40

50 NULL

Following are the operations of linked lists: getnode() – creates a node for the linked list. freenode() – releases the memory acquired by the node . insertAt(int item, int pos) – insert the new element in the linked list by inserting a new node. deleteAt(int pos) – delete a node from the linked list. append(int item) – append new node at the end of the list.

14

3.1.1. How to create a singly linked list? Following are the steps to create singly linked list. In this example, we are crating a singly sorted linked list. Step1: Declare Self-referential structure
typedef struct node { int info; /*data part of node*/ struct node *next; /*pointer to the next node*/ } DATANODE;

Step2: getnode() operation for the linked list.
getnode() : This operation creates new node for the linked list. DATANODE *getnode() { DATANODE *temp = (DATANODE *) malloc(sizeof(DATANODE)); temp->next = NULL; }

Step3:freenode() operation for the linked list..
freenode() : This operation is used to free the memory allocated to the node. This operation is essential if the linked list contains complex data. It may be needed to release all the resources acquired by the node. void freenode(DATANODE *ptr) { free(ptr); /*deallocated memory of DATANODE pointed by ptr.*/ }

Stepr4: Operation to append new node in the sorted linked list.
append(): This operation will attach new node as the last node in the sorted linked list. void append(DATANODE **head, int value) { DATANODE *p=NULL, *new=NULL; /* Create new node.*/ new = getnode(); new->info = value; if (*head == NULL) /* List is empty. New node will be appended as the first node in the list.*/ { *head = new; return; } /*Traverse the list till the end.*/ p = *head; while(p->next) p = p->next;

15

}

/*Append new node.*/ p->next = new;

Step5: Operation to insert new node in the sorted list.
insert(): This operation is used to insert new node in the existing sorted linked list. void insert(DATANODE **head,int value) { DATANODE *p=NULL, *q=NULL, *new=NULL; int i=1; /*Create new node. */ new = getnode(); new->info = value; if ( *head == NULL) /* Linked List Is Empty.*/ { *head = new; /* New node becomes the first node in the linked list.*/ } return;

if ( (*head)->info > value) /* New node has smallest value in the list.*/ { new->next = *head; *head = new; return; } /*Traverse list to reach specific position.*/ p = *head; while ( p && p->info <= value) { q = p; /* q follows p*/ p = p->next; /* p moves to the next node.*/ } /* Insertion between q and p.*/ q->next = new; new->next = p;

}

16

Step6: Operation to delete node from the sorted linked list.
del(): This operation removes the specified node from the list and then that node will be deallocated. void del(DATANODE **head, int value) { DATANODE *p=NULL, *q=NULL; if (*head == NULL) { printf("Error :: Linked List Is Empty.!"); exit(1); } if ((*head)->info == value) /*First node contains value.*/ { p = *head; *head = (*head)->next; /*Second node will become first in the list.*/ freenode(p); /*Delete node pointed by p.*/ return; } /*Traverse the list to search for specific node.*/ p = *head; while(p) { q=p; /*q follows p.*/ p=p->next; } if (!p) { }

printf("Data Not Found In The List.!"); return;

/*Remove node pointed by p from the list.*/ q->next = p->next; } freenode(p); /*Delete node pointed by p.*/

17

Step7: Operation to display all nodes of the linked list.
display(): This operation will display data present in all nodes of the list. void display(DATANODE *p) { /*Traverse till the end of the list.*/ while (p) { printf("%d ", p->info); p = p->next; } }

Step8: Operation to delete all nodes of the list.
destroylisr(): This operation will delete all nodes of the list. This operation is required after the use of linked list in application is over. This will release the memory acquired by the list. void destroylist(DATANODE **head) { DATANODE *p = NULL; p = *head; while (p) { *head = p->next; /*Shift head pointer to the next node.*/ freenode(p); /*Delete the node previously pointed by head.*/ p = *head; } }

18

Program Listing: Sorted Singly Linked List.
/* Program to implement sorted singly linked list.*/ #include <stdio.h> /*for input/output operations*/ #include <malloc.h> /*for accessing library functions: malloc(), free()*/ #include <stdlib.h> /*for accessing library functions such as exit()*/ /* Declare Self Referential Structure for creating nodes of linked list.*/ typedef struct node { int info; /*data part of node*/ struct node *next; /*pointer to the next node*/ } DATANODE; DATANODE *getnode(); /* Creates New Data Node.*/ void freenode(DATANODE *ptr); /*Deallocates the memory assigned to datanode.*/ void insert(DATANODE **head,int value);/*Inserts new node at the specified position.*/ void del(DATANODE **head, int value);/*Delete the node from specified position.*/ void append(DATANODE **head, int value);/*Add new element as the last node in the linked list.*/ void display(DATANODE *head);/*Display all elements of the linked list.*/ void destroylist(DATANODE **head); /*Delete all nodes from the list.*/ int main() { int num,n,i; DATANODE *list = NULL; /* Initialize linked list.*/ printf("Program to store integers in sorted order.\n"); printf("How many Numbers?:"); scanf("%d",&n); /* Append first number in the list.*/ i = 1; printf("Enter Number %d:",i); scanf("%d",&num); append(&list,num); /*Insert remaining numbers in the list.*/ while(i < n) { i++; printf("Enter Number %d:", i); scanf("%d",&num); } insert(&list,num);

19

printf("The linked list is as follows......\n"); display(list); /*Delete all nodes from the linked list to free memory locations.*/ destroylist(&list); return 0;

}

DATANODE *getnode() { DATANODE *temp = (DATANODE *) malloc(sizeof(DATANODE)); /* create node of type DATANODE.*/ temp->next = NULL; } void freenode(DATANODE *ptr) { free(ptr); /*deallocated memory of DATANODE pointed by ptr.*/ } void insert(DATANODE **head,int value) { DATANODE *p=NULL, *q=NULL, *new=NULL; int i=1; /*Create new node. */ new = getnode(); new->info = value; if ( *head == NULL) /* Linked List Is Empty.*/ { *head = new; /* New node becomes the first node in the linked list.*/ return; } if ( (*head)->info > value) /* New node has smallest value in the list.*/ { new->next = *head; *head = new; return; } /*Traverse list to reach specific position.*/ p = *head; while ( p && p->info <= value) { q = p; /* q follows p*/ p = p->next; /* p moves to the next node.*/ } /* Insertion between q and p.*/ q->next = new; new->next = p;

}

20

void append(DATANODE **head, int value) { DATANODE *p=NULL, *new=NULL; /* Create new node.*/ new = getnode(); new->info = value; if (*head == NULL) /* List is empty. New node will be appended as the first node in the list.*/ { *head = new; return; } /*Traverse the list till the end.*/ p = *head; while(p->next) p = p->next; /*Append new node.*/ p->next = new;

}

void del(DATANODE **head, int value) { DATANODE *p=NULL, *q=NULL; if (*head == NULL) { printf("Error :: Linked List Is Empty.!"); exit(1); } if ((*head)->info == value) /*First node contains value.*/ { p = *head; *head = (*head)->next; /*Second node will become first in the list.*/ freenode(p); /*Delete node pointed by p.*/ return; } /*Traverse the list to search for specific node.*/ p = *head; while(p) { q=p; /*q follows p.*/ p=p->next; } if (!p) { }

printf("Data Not Found In The List.!"); return;

/*Remove node pointed by p from the list.*/ q->next = p->next;

21

}

freenode(p); /*Delete node pointed by p.*/

void display(DATANODE *p) { /*Traverse till the end of the list.*/ while (p) { printf("%d ", p->info); p = p->next; } } void destroylist(DATANODE **head) { DATANODE *p = NULL; p = *head; while (p) { *head = p->next; /*Shift head pointer to the next node.*/ freenode(p); /*Delete the node previously pointed by head.*/ p = *head; }

}

Compile and run this program as follows to see the output: #> cc SortedSinglyLinkedList.c #> ./a.out 1. Modify this program to delete repetitive elements from the list. 2. Modify this program to add header node in the linked list. Header node should contain a count of total nodes present in the linked list.

3.2. Doubly Linked List Need for doubly linked list: In singly linked list o traversing is possible only in forward direction. o If the value to be searched in a linked list is toward the end of the list, the search time would be higher. In doubly linked list, traversing is possible in both directions and search can be continued from any node in between either in forward of backward direction. Characteristics of doubly linked list In a doubly linked list, each node has two pointers, one pointing to the next node in the list, and the other pointing to previous node in the list. Previous pointer of first node is always NULL in doubly linked list. Last node’s next pointer is always NULL in doubly linked list.

22

Prev

info

Prev

Head
NULL

10

20

30

40

NULL

Operations of doubly linked list Doubly linked contains same operations as in singly linked list. If required, traversing for doubly linked could be implemented in reverse order. Self Activity Let’s create doubly linked list. Following are the steps to create doubly linked list. In this example, we are crating a doubly sorted linked list. Step1: Declare Self-referential structure
typedef struct node { struct node *prev; /*pointer to the previous node.*/ int info; /*data part of node*/ struct node *next; /*pointer to the next node*/ } DATANODE;

Step2: getnode() operation for the linked list.
getnode() : This operation creates new node for the linked list. DATANODE *getnode() { DATANODE *temp = (DATANODE *) malloc(sizeof(DATANODE)); temp->prev = NULL; temp->next = NULL; }

Step3: freenode() operation for the linked lisr.
freenode() : This operation is used to free the memory allocated to the node. This operation is essential if the linked list contains complex data. It may be needed to release all the resources acquired by the node. void freenode(DATANODE *ptr) { free(ptr); /*deallocated memory of DATANODE pointed by ptr.*/ }

23

Stepr4: Implement function to append new node in the sorted doubly linked list.
append(): This operation will attach new node as the last node in the sorted linked list. void append(DATANODE **head, int value) { DATANODE *p=NULL, *new=NULL; /* Create new node.*/ if (*head == NULL) first node in the list.*/ { } /* List is empty. New node will be appended as the

/*Traverse the list till the end.*/ } /*Append new node.*/

Step5: Implement function to insert new node in the sorted doubly list.
insert(): This operation is used to insert new node in the existing sorted list. void insert(DATANODE **head,int value) { DATANODE *p=NULL, *q=NULL, *new=NULL; int i=1; /*Create new node. */ if ( *head == NULL) /* Linked List Is Empty.*/ { } if ( (*head)->info > value) /* New node has smallest value in the list.*/ { } /*Traverse list to reach specific position.*/ p = *head; while ( p && p->info <= value) { } /* Insertion between q and p.*/ }

24

Step6: Implement function to delete node from the sorted doubly linked list.
del(): This operation removes specified node from the list and then that node will be deallocated. void del(DATANODE **head, int value) { DATANODE *p=NULL, *q=NULL; if (*head == NULL) { } if ((*head)->info == value) /*First node contains value.*/ { } /*Traverse the list to search for specific node.*/ p = *head; while(p) { } if (!p) { } /*Remove node pointed by p from the list.*/ freenode(p); /*Delete node pointed by p.*/

}

Step7: Implement function to display all nodes of the doubly linked list in forward as well as reverse order.
display(): This operation will display data present in all nodes of the list. void display(DATANODE *p) { /*Traverse till the end of the list.*/ while (p) { printf("%d ", p->info); p = p->next; } /*Traverse the list in reverse till we reach to the first node in the list.*/

}

25

Step8: Operation to delete all nodes of the list.
destroylisr(): This operation will delete all nodes of the list. This operation is required after the use of linked list in application is over. This will release the memory acquired by the list. void destroylist(DATANODE **head) { DATANODE *p = NULL; p = *head; while (p) { *head = p->next; /*Shift head pointer to the next node.*/ freenode(p); /*Delete the node previously pointed by head.*/ p = *head; }

}

NOTE: 1. Please note that the above programs and program skeletons are guidelines for students. You are free to implement linked list by your own method under the guidance of teacher. 2. Linked list with header node will simplify insertion and deletion operations. Please concern your teacher to know more about it. Practical Assignments SET A 1. Write a C program to implement singly linked list of integers using array. 2. Write a C program to implement circular singly linked list. What are the advantages of circular singly list over linear singly list? 3. Write a C program to implement doubly circular linked list. What are the advantages of circular double linked list over linear doubly linked list? SET B 1. Write a C program to perform union, intersection operations on two sorted linked lists. 2. Write a C program to add two polynomials using linked list. 3. Write a C program to multiply two polynomials.

26

SET C 1. Write a C program to sort the singly linked list of integers. (Create an unsorted list and then sort it. 2. Write a C program to merge two sorted linked list. 3. Write a C program to create linked list of strings. Display all strings containing same substring. (Accept substring from user.) Assignment Evaluation 0: Not Done [ ] 3:Needs Improvement [ ] 1:Incomplete [ ] 4:Complete [ ] 2.Late Complete [ ] 5:Well Done [ ]

Signature of the Instructor

Date of Completion ____/____/______ End of Session

27

SESSION 4: Stack
Objectives To learn about: Concept of Stack Operations on stack Implementation of stack using array Implementation of stack using linked list Applications of Stack Reading

Start Date ___/____/______

You should read following topics before starting the exercise. Linked list implementation Stack as a data structure and all its applications Ready References 4.1. Stack In stack, insertion and deletion is possible only from one end called as top of the stack. It is a LIFO(Last In First Out) data structure. Following operations are possible on stack: push(stk,x) Data item x can pushed into stack stk. The size of stack stk is increased by 1. Top of the stack stk will be pointing to the last inserted element x. This operation is always valid because stack doesn’t have any upper limit. But, if stack is implemented using array then it can grow up to the size of array. If array is full, push() operation is not possible. This condition is called as “Stack Overflow Condition”. x = pop(stk) Topmost element of stack is removed from stack stk. The size of stack is reduced by 1 after this operation. This operation is invalid if stack is empty. The pop() operation on empty stack results into “Stack Underflow” condition. x = stacktop(stk) This operation returns the copy of topmost element present in stack stk. It does not remove it. The size of stack is unchanged after this operation. This operation is invalid if stack is empty. The stacktop() operation on empty stack results into “Stack Underflow” condition. empty(stk) The empty() operation returns true if the stack is empty, otherwise it returns false. 28

Self Activity Let’s implement Stack using Array (Static Representation) Step1. Define structure to hold Stack as a single entity. typedef struct Stack { int data[MAXSIZE-1]; int top; } STACK; Step2: Implement initlist() operation for the Stack. void initlist(STACK *stk) { /* Write a code to initialize top pointer to -1 */ } Step3: Implement push() operation. void push(STACK *stk, int item) { /* Write a code to check for “Overflow Condition.” */ /* Write a code to add new item at the top of stack.*/

}

Step4: Implement pop() operation. int pop( STACK *stk) { /* Write a code to check for “Overflow Condition”. */ /* Write a code to delete and return topmost element from the stack.*/ } Step5: Implement stacktop() operation. int stacktop( STACK *stk) { /* Write a code to check for “Overflow Condition”. */ /* Write a code to return a copy of topmost element from the stack.*/ }

29

Step6: Implement empty() operation. int empty(STACK *stk) { /* if top is -1, the list is empty. */ } Let’s Implement Stack using Linked list (Dynamic Representation) Following are some guidelines to implement stack using linked list: 1. Define a structure for stack. typedef struct { int info; struct node *next; } Stack; 2. Declare stack pointer which will be treated as top pointer. Stack *top = NULL; 3. Implement push() function void push(Stack **top, int item) { /* Write a code to insert new node (new element of stack) at first position of the linked list. In other words, top pointer will be always pointing to newly inserted node in the linked list.*/ }

top

10

20

30

push(&top, 5);

top

5

10

20

30

push(&top, 2);

2 5 top 4. Implement pop() function.
int pop(Stack **top) {

10

20

30

30

}

/* Write a code to delete first node from the list.*/ /*Return data from deleted node.*/

top

2

5

10

20

30

X = pop(&top);

top

5

10

20

30

2 Deleted Node

X = pop(&top); top 10 20 30 5 Deleted Node
5. Implement stacktop() function. int stacktop(Stack **top) { /*Write a code to return the value of the first node without deleting it.*/ } 6. Implement empty() function. int empty(Stack **top) { } Practical Assignments SET A 1. Write a C program to reverse a string using static stack. (Create Stack.h file.) 2. Write a C program to check whether the string is palindrome or not using dynamic stack. (Use Stack.h file.) 3. Write a recursive functions to solve following problems: a. Towers of Hanoi problem with n disks. (n must be accepted from user.) b. Calculate power of x to the n. c. Fibbonacci series. 31

Does all these functions are implemented using stack? If yes, How they are using stack? SET B 1. Write a C program to convert infix expression into postfix form and evaluate it. 2. Write a C program to convert infix expression into prefix form and evaluate it. SET C 1. Write a C program to simulate recursion of following functions: a. Factorial of n numbers b. Power function 2. Write a C program to simulate recursion of Towers of Hanoi function. Assignment Evaluation 0: Not Done [ ] 3:Needs Improvement [ ] 1:Incomplete [ ] 4:Complete [ ] 2.Late Complete [ ] 5:Well Done [ ]

Signature of the Instructor

Date of Completion ____/____/______ End of Session

32

SESSION 5: QUEUE
Objectives To learn about: The data structure QUEUE QUEUE as an Abstract Data Type Types of QUEUE Operations on QUEUE Static QUEUE Dynamic QUEUE Applications of QUEUE Reading

Start Date ___/____/______

You should read following topics before starting the exercise: concept of queue Representation of queue using array and linked list Concept of circular queue, dequeue, priority queue. multiple queues Ready References 5.1. Queue Definition: A queue is an ordered collection of items, from which items may be deleted from one end called the front, and into which items may be inserted at the other end called the rear end of the queue. QUEUE as an Abstract Data Type : The QUEUE is a FIFO (First In First Out) structure. We use this term many a times in our day to day activities. E.g. Cinema QUEUE, bus QUEUE etc. There are 2 active pointers to QUEUE, front and rear. We follow certain rules: 1) All additions at the rear end and all deletions from the front end It means that we always add new elements towards the rear end and we always delete the elements from the front end. 2) We normally use one of the following strategies: a) Increment rear and then add at that position OR b) Add at the rear position and then increment rear. Depending upon the strategy you choose, you can initialize the front and rear. For strategy a) we initialize front = -1, rear = -1; For strategy b) we initialize front = 0, rear = 0;

33

In the static implementation of queue front and rear are integers as they are giving the location of the array where delete / insert should take place. In the dynamic implementation of queue front and rear are pointers. Types of Queue: 1) 2) 3) 4) Linear queue Circular queue Priority queue Double Ended Queue (DEQUE)

All those types can be implemented either statically or dynamically. 5.2. Implementation of linear queue using array (static representation) Static implementation is array based implantation. This requires a structure (using struct keyword) as it allows us, user defined datatype declaration (Q becomes user defined datatype). Inside the structure we declare an array to store int data, and two pointers front and rear.
Front Rear

10 20 30
0 1 2

40 50
3 4

60
5

70 80 90
6 7 8

Operations on a QUEUE : Different operations possible on a queue are as follows: 1) Create: This creates a new empty queue. #define MAX 10 typedef struct QUEUE { int data[MAX]; int rear, front; } Q; Q q1, q2; /* create 2 queues. */ Q *P; P = &q1; 2) Initialize : Initialize the rear and front pointers for an empty queue. If we use increment rear and add at that position strategy, we initialize front and rear to -1, if we adopt the other strategy, we initialize both front and rear to zero. void initq( Q * P) { P -> rear = -1; P -> front = -1; } 34

3) Add or insert : Adds a new element to the queue at the rear end. The operation can only be performed if the queue is not full. If the queue is full, and we try to add an element, an overflow results. int addQ(Q*p, int x) { if (! isfull(p)) { p->data[++(p->rear)] = x; return 1; } return 0; } 4) Delete : Removes an element from the front end of the queue. The operation can only be performed if the queue is not empty. int delQ(Q * P) { if( !isempty(P) ) return ( P -> data[++ ( P->front)]); else return 0; } 5) Isempty : Checks whether a queue is empty, returns TRUE if queue is empty and FALSE otherwise. int isempty(Q *P) { if (P->front = = P->rear) return 1; else return 0; } 6) Isfull : Checks whether a queue is full, returns TRUE if queue is full and returns FALSE otherwise. If rear reaches MAX -1, but front is not -1, so some empty positions exist at the beginning of the queue. Now this situation is tackled in 2 ways. Method 1: Let the positions be empty only. This will cause wastage of memory locations. int isfull(Q *P) { if(p->rear == MAX -1) { printf(“Q is full “ ) ; return 1 ; } else return 0 ; } 35

Method 2: If empty positions at beginning of queue, and rear reaches MAX – 1 then perform shift queue to reuse empty locations in the array. int isfull(Q *P) { if(p->rear == MAX -1) { if (p->front == -1) return 1 ; else shiftq(p) ; return 0 ; } 7) ShiftQ : As there are 2 active ends, (all additions at the rear end and all deletions from the front end,) even if you add at the rear end some locations towards begining of the queue might be empty. You have to reset the front pointer when rear reaches the MAX -1 position. i.e. You have to shift the queue elements to the beginning of the queue periodically( or when rear reaches MAX – 1) to get the free spaces at the rear end. ) sothat the empty locations can be utilized. void shiftQ( Q *P) { int topos =0, frompos; for( frompos = P->rear; frompos < MAX; frompos++) P->data[topos++]=P->data[frompos]; P->front = -1; P->rear = topos-1; } 8) Display: Print elements of the queue. 5.3 Implementation of queue using linked list (Dynamic Queue) The word dynamic refers to run time allocation of memory. So for this purpose we use malloc(), calloc() kind of functions for run time memory allocation. Here, we get the memory allocated as per requirement. Therefore, the maximum number of items in the Queue we need not mention. Items can be linked together , so the item is stored in one node of the linked list. As and how we want to store an item , we get one node allocated. The declaration will look like this: typedef struct QUEUE { int data; struct QUEUE *next; }QNODE; QNODE *front, *rear; In the initialize function we can initialize front and rear to NULL; 36

For a dynamic queue except shiftQ() ,we write all the above functions. shiftQ() is not written because we are not required to shift the queue elements.

front 10 20 30 40 50

rear

5.4 Circular Queue This queue also will not require shiftQ() function. Works like a clock. The first and the last positions are coming side by side. Also if MAXSIZE is 6( positions available are 0 to 5), then the 7th item should be placed in the zeroth position. i.e. We have to increment rear to rear + 1 % MAX when rear reaches to MAX1 and front to front +1 % MAX when front reaches to MAX -1.Here one position from the queue will be underutilized. typedef struct CirQ { int items[MAX]; int front, rear; }Q; Functions for Circular Queue: 1. Initialize Queue void initQ (Q* cq) { cq-> front = cq->rear = MAX -1; } 2. IsemptyQ Prototype: int isemptyQ(Q *cq) Queue will be empty if rear = front 3. IsfullQ int isfullQ(Q* cq) { return ((cq->rear+1)% MAX == cq->front) 4. AddQ Prototype: int addQ(Q *cq, int item) If Q is not full, then increment rear to (rear +1) % MAX and then add at that position. 5. DelQ Prototype: int delQ(Q *cq) While deleting increment front to (front + 1) % MAX and then delete. Return the deleted element 5.5 Priority Queue Definition: A priority Queue is a data structure in which the intrinsic ordering among the elements decides the result of its basic operations. 37

Types of priority Queue : 1. Ascending Priority Queue : Elements can be inserted arbitrarily but only the smallest element gets deleted first 2. Descending Priority Queue: Only the largest element gets deleted first. 5.6 Dequeue This is Double Ended Queue. A DEQUE is a linear list in which elements can be added or removed at either end. Elements can be added or removed from front or the rear end. A DEQUE is generalization of a stack and a queue. Types of DEQUE: 1. Input restricted DEQUE : allows insertin at only one end of the list but allows deletion from both the ends. 2. Output restricted DEQUE : allows deletion at only one end of the list, but allows insertion at both ends of the list. Operations possible are: Enquefront() : To add at front end of the queue. Enquerear() : To add at rear end of the queue. Dequeuefront() : To delete item at the fron end of the queue. Dequeuerear() : To delete an item at rear end of queue. Practical Assignments SET A 1. Write a C program to implement linear queue of strings using array. Store the structure and queue functions in “queue.h” and write the main function in a .C file. The program should be menu driven with the options : ADD, DELETE, EXIT. typedef struct { // members }queue; void initq(queue *pq) { } int isempty(queue *pq) { } int isfull(queue *pq) { } void addq(queue *pq, char *str) { } char *delq(queue *pq) { } void main() { queue q;
//menu driven program }

2. Write a C program to implement a circular queue using array. (Refer to the code above) 38

3. Write a C program to implement a queue of integers using linked list. The program should be menu driven with the following options: ADD, DELETE, EXIT. typedef struct node { // members }NODE; NODE *front, *rear; //global variable void initqueue() { } void addq(int n) { } int delq() { } int isempty() { } void main() { //menu driven program } SET B 1. Write a C program to implement static ascending priority queue. 2. Write a C program to sort n integers using bucket sort method. SET C 1. Write a C program to implement static DEQUE. 2. Write a C program to implement Multiple Queues using single array. 3. Write a C program to implement Josephus problem. Assignment Evaluation 0: Not Done [ ] 3:Needs Improvement [ ] 1:Incomplete [ ] 4:Complete [ ] 2.Late Complete [ ] 5:Well Done [ ]

Signature of the Instructor

Date of Completion ____/____/______ End of Session

39

SESSION 6: Tree
Objectives To learn about: The data structure Tree Tree as an Abstract Data Type Types of Tree Operations on Tree Applications of Tree Reading

Start Date ___/____/______

You should read following topics before starting the exercise. Concept & Terminologies of Binary tree and binary search tree Operations on BST – create. Insert, delete, traversals (preorder, inorder, postorder), counting leaf, non-leaf & total nodes Application - Heap sort, Height balance tree- AVL trees- Rotations Ready References Tree can be treated as a special case of generalized link list. 6.1 Binary Tree A binary tree is a special form of a tree. A binary tree is finite set of nodes, which is empty or partitioned into 3 sets, one which is the root and the other 2 are binary trees called its left and right subtrees. It is a tree where every node can have at the most two branches or children. Some frequently used types of binary trees are as follows: 1. Binary Search Tree (BST) 2. Expression Tree 3. Heap Tree 4. Threaded Binary Tree 5. Huffman Tree 6. Height Balanced Tree (AVL tree) 6.2 Binary Search Tree (BST) Definition: A binary search tree is a binary tree, which is either empty or in which each node contains a key that satisfies following conditions: 1) For every node X, in the tree the values of all the keys in its left subtree are smaller than the key value in X. 2) For every node X, in the tree the values of all the keys in its right subtree are larger than the key value in X.

40

Structure of a node of a BST: typedef struct BST { int data; struct BST * left, * right; }BSTnode; Operations on a binary Search Tree: 1. Create: creating a binary search tree(BST).A BST can be created by making repeated calls to insert operation.
BSTnode * create() { int i, totnodes, val; BSTnode * root =NULL; printf(“ How many nodes to create?”); scanf(“%d”, &totnodes); printf(“Enter node values : “); for ( i=0;i<totnodes;i++) { scanf(“%d”,&val); root = insert(root, val); } return ( root); }

2. Insert: Inserting one node in the BST.
BSTnode * insert(BSTnode * T, int x) { if ( T = = NULL) { T = (BSTnode*) malloc (sizeof(BSTnode)); T-> data = x; T->left = NULL; T->right = NULL; return (T); } if(x > T->data) { T-> right = insert(T->right, x); return (T); } T->left = insert(T->left, x); return (T); }

3. Delete: a) b) c)

Deleting one node of the BST. There are 3 cases: deleting a leaf node deleting a node with one child deleting a node with 2 children

4. Traversal: To visit all nodes and print the data of the BST. There are 3 types of traversals: inorder, preorder, postorder.

41

5. Findmin: Finds the minimum value in the BST. This value is situated in the leftmost node of the BST. BSTnode * findmin(BSTnode *T) { while (T->left != NULL) T = T->left; return(T); } 6. Findmax : Finds the maximum value of the BST. This value is situated at the rightmost position of BST. Prototype : BSTnode * findmax(BSTnode *T) 7. Find: finds the value X in the BST Prototype : BSTnode * find(BSTnode, int x) 6.3. Heap Tree Types of heaps: a) MaxHeap : A max heap is a complete binary tree with the property that the value of each node is at least as large as the values at its children. In the max heap the largest element is at the root. b) MinHeap : A min heap is a complete binary tree with the property that the value at each node is at least as small as the values at its children. Here, the smallest element is at the root. Sorting in ascending order: The best known application of heap is in sorting. It uses a very simple strategy for sorting. A heap can be sorted through repeated application of delete max( ) in the Maxheap. An array can be used for heap sort. Accept all values in an array where at zeroth position total number of values are stored. Algorithm : Step 1: Construct a max-heap. heap[0] has total values n and heap[1] is largest element. Step 2: Swap heap[1] and heap[n]. This will put largest at heap[n]. Step 3: Reduce the heap size by 1. i.e. heap[0] = heap[0] – 1; Largest element is in the array but it is not a part of the heap. Step 4: The new tree represented by heap[1..n-1] may no longer be a heap, as heap[1] is changed. The new tree can be converted to a heap by using a function downadjust(). Step 5 : Repeat steps 2 to 4, while number of elements in the heap > 1 ( i.e. heap[0] > 1)

42

Function to create the max-heap: void create(int heap[]) { int i,n; n = heap[0]; for ( i=n/2; i>=1; i--) down_adjust(heap,i); } Function to readjust the heap void down_adjust(int heap[], int i) { int j, temp, n,flag = 1; n= heap[0]; while (2*i <= n && flag = = 1) { j = 2 *i; /* j points to left child */ if ( j + 1 <=n && heap[j+1] > heap[j]) j=j+1; if (heap[i] > heap[j]) flag = 0; else { temp = heap[i]; heap[i] = heap[j]; 43

heap[j] = temp; i = j; }/* end if */ }/* end while */ }/* end down adjust */ Function to sort the array elements: Sort(int heap[]) { int last, temp; while (heap[0] > 1) { /* swap heap[1] with heap[last] */ last = heap[0]; temp = heap[1]; heap[1] = heap[last]; heap[last] = temp; heap[o]--; down_adjust(heap,1); } }

Practical Assignments SET A 1. a) Write a menu driven program for Binary Search Tree creation and inorder, preorder, postorder recursive traversal of all nodes. b) Modify the above program for performing following operations : a. Search a value. b. Insertion of a value 2. Write a program to perform Heap-sort using arrays. SET B 1. Write a program to create Binary Search tree with the following functions: a) tcopy - function to make an identical copy of a tree T, returns root of newly created tree b) tmirror – checks whether a tree t1 is a mirror image of tree t2, returns 1 if true else returns 0 c) tleafcnt - counting leaf nodes of a tree T 2. Write a program to create and evaluate expression tree. 3. Modify program in set A (Exercise 1) to perform deletion of a node in the BST 44

SET C 1. Write a program to perform Non-recursive traversal using stack(inorder, preorder, postorder) on the BST 2. Write a program to create height balanced tree. Write appropriate functions for different cases- LL, RR, LR, RL to rotate the tree and maintain the balance. 3. Write a program to create Huffman tree for compression. Assignment Evaluation 0: Not Done [ ] 3:Needs Improvement [ ] 1:Incomplete [ ] 4:Complete [ ] 2.Late Complete [ ] 5:Well Done [ ]

Signature of the Instructor

Date of Completion ____/____/______ End of Session

45

SESSION 7: Graph
Objectives

Start Date ___/____/______

To learn about: Implementation of adjacency matrix and adjacency list Implementation of adjacency mult-ilist Graph traversal – BFS and DFS Shortest path algorithm – Dijkstra’s Algorithm Reading You should read the following topics before starting the exercise. 1. Graph Terminologies - vertex, edge, graph, path, complete graph, 2. Graph representation techniques – Adjacency matrix, Adjacency list 3. Examples on Adjacency matrix, Adjacency list Ready References 7.1 Representation of Graph If we want to represent cities and highways connecting them, we can represent this information in the form a graph. Or components on circuit board with the connections among them. An organic chemical compound can be considered as a graph with atoms as the vertices and the bonds between them as edges. For such need most suitable data structure is ‘graph’. In computer systems graph can be stored using adjacency matrix, adjacency list or adjacency multilist. Adjacency Matrix A adjacency matrix A has a natural interpretation as A[v,w] = 1 iff vertex v is adjacent to vertex w, otherwise A[v,w] = 0(if not adjacent) Example: 0
V1 V2

1 0 0 1

0 1 0 1

0 1 0 0 Adjacency Matrix

0 Graph G
V4 V3

0 1

Adjacency List: Another way to represent a graph is adjacency list. This is linked list representation of graph; there is one list for each vertex in the graph. Thus for ‘n’ vertices, n list will be prepared. Each node of the list I consists of 1. Vertex numbers to which vertex I is adjacent 2. Pointer to the next node in the list 46

Example: For above graph G adjacency list: V1
V2 NULL

V2

V3

V4

NULL

V3

NULL

V4

V1

V2

V3

NULL

7.2 Graph Traversal Methods In many problems we wish to investigate all the vertices in a graph in some systematic order, just as with binary trees we developed several systematic traversals methods. In tree traversal, we had w root as a starting vertex; in graph we often do not have any one vertex as a special, and therefore the traversal may start at an arbitrary vertex. This lecture focus on graph traversal techniques - DFS, BFS. 1. Depth First Traversal/Search: Depth first traversal of a graph is roughly analogous to preorder traversal of an ordered tree. Suppose that the traversal has just visited a vertex v, and let w1,w2…….wk be the vertices adjacent to v. Then we shall visit w1 and keep w2……wk waiting. After visiting w1 we traverse all the vertices to which it is adjacent before returning to traverse w2…..…wk. 1. 2. 3. 4. 5. 6. Algorithm Initialize visited array to 0 v is the starting vertex visited [v] = 1 display v Search for w which is an unvisited vertex adjacent to v if w is found Visited [w] =1 Display w Push w into stack Go to 5 v=pop Continue from 5 till stack becomes empty Stop.

7. 8. 9.

2. Breadth First Traversal/Search: Breadth first traversal of a graph is roughly analogous to level-by-level traversal of an ordered tree. If the traversal has just visited a vertex v, then it next visits all the vertices adjacent to v, putting the vertices adjacent to these in a waiting list to be traversed after all the vertices adjacent to v have been visited. 47

1. 2. 3. 4. 5. 6. 7.

8.

Algorithm Initialize visited array to 0 v is the starting vertex Queue is initialized visited [r] =1 add v to queue Remove v from queue and display to v for all vertices w adjacent to v if visited [w]=1 add w to queue visited [w] =1 Continue from 6 till queue becomes empty

7.3 Applications of Graph Topological Sort Graphs are commonly used for project planning which consists of many interdependent activities. These activities are represented as vertices and the directed edges represent the order of activities. Such graph is called an Activity On Vertex (AOV). The process of converting a set of precedence represented by an AOV network into a linear list in which no later activity precedes an earlier one is called topological sorting. 1. 2. 3. 4. Algorithm Accept AOV network in adjacency list form S is an empty stack Search for vertex v whose in-degree is 0 if v is not found if stack is empty go to 9 else go to 5 if not found if stack is empty go to 8 else go to 5 if found make in-degree of v = -1 push v into stack pop v from the stack and display Reduce the in-degree of all vertices adjacent to v by 1 Repeat from step 3 till all vertices have been visited Stop.

5. 6. 7. 8. 9.

Shortest Path Algorithm Graphs are often used to represent the road network of a state or country with the vertices representing cities and the edges representing the connecting roads. Each edge may be assigned a weight which may be the 48

distance between the two vertices or the time taken to go from one vertex to another. An algorithm devised by Dijkstra is a ‘single source all destinations’ algorithm which gives the shortest path from a given vertex to all other vertices in the network. 1. V is the starting vertex 2. Initialize visited array to 0 3. Initialize all the elements of distance array as Dist [i] = cost [v] [i] 4. visited [v] =1 5. num=1 6. while (num <n) { u=choose (dist, n); num=num+1 /* choose is the function which returns u such that Dist [u] = min{ dist[w]} where visited [w] is false */ For w= 1 to n-1 { If (!visited[w] ) If (dist[u]+cost[u][w]<dist[w]) Dist[w]=dist[u]+cost[u][w] } } 7. dist array contains the shortest paths from V to all other destinations 8. Stop Algorithm

Practical Assignments SET A 1. Write a program to read a graph as adjacency matrix. Calculate indegree,outdegree and total degree of each vertex. Also write functions to implement BFS and DFS. (Use recursive DFS function.) 2. Write a program to read a graph as adjacency matrix and convert it into adjacency list. Write BFS and non-recursive DFS functions.

49

SET B 1. Write a program to represent following graph as an adjacency multilist form. B

A

D

C 2. Write a program to represent following graph as an Orthogonal list. B

A

D

C 3. Implement a graph using an array of adjacency lists. Under this representation, a graph of n nodes consists of n header nodes, each containing an integer from 0 to n-1 and a pointer. The pointer is to a list of list nodes each of which contains the node number of a node adjacent to the node represented by the header node. Implement Dijkstra’s algorithm using this graph representation. SET C 1. Write a program to implement Prim’s algorithm using an adjacency matrix. 2. Write a program to implement Kruskal’s algorithm using an adjacency matrix / adjacency list. 3. There may be more than one way to organize set of subtasks in a minimum number of time periods. For example, the subtask in following figure may be completed in six time periods in one of three different methods:

50

Period 1 2 3 4 5 6 A, F B, H I C D E A

Method 1 F A, H B, I C D E D

Method 2 A, F H B, J C D E F

Method 3

G B E

C Write a program to generate all possible methods of organizing the subtasks in the minimum number of time periods. Assignment Evaluation 0: Not Done [ ] 3:Needs Improvement [ ] 1:Incomplete [ ] 4:Complete [ ] 2.Late Complete [ ] 5:Well Done [ ]

Signature of the Instructor

Date of Completion ____/____/______ End of Session

51

Sign up to vote on this title
UsefulNot useful