You are on page 1of 173

DATA STRUCTURES IN C MADE SIMPLE

( Second Edition)

KANNAN BALAKRISHNAN

SUMI HARIDAS

UMESH RAM

2011

Preface
For many years the authors have felt the need of a simple book in data structures. This book is written especially for students in undergraduate classes. We have included basic concepts like stacks ,queues, linked lists, graphs, trees, searching and sorting algorithms in this book.Even though we do not claim any in depth treatment of the subject in this book, we hope that it will be surely useful for students who are studying data structures in C for the first time. Many programs are included in the book. Also a companion blog i s available at http://dssimple.wordpress.com .

We hope that this book will be of great use to students. Cochin 24.11.11 Authors

TABLE OF CONTENTS
Chapter 1

Pointers 1.1 What Is A Pointer? 1.2 Pointer Declaration 1.3 Pointer Arithmetic 1.4 Accessing Variables Using Pointer 1.5 Address Operator (&) 1.6 Dereferencing Operator (*) 1.7 .One And Two Dimensional Arrays Using Pointers 1.8 Void Pointers 1.9 Pointers In Function Arguments 1.10 Recursion 1.11 Direct Recursion 1.12 Indirect Recursion 1.13 Array Of Pointers 1.14 Pointer To Pointer 1.15 Pointers To Strings 1.16 Pointers to functions Exercises Chapter 2 Structures and Unions 2.1 Definition 2.2 Accessing The Members Of A Structure 2.3 Array Of Structures 2.4 Structures Within Structure (Nested Structure) 2.5 Pointers To Structures 2.6 Structure In Functions 2.7 Unions 2.8 Difference and Similarity Between Structure And Union Exercises Chapter 3 Strings and String Operations 3.1 Strings 3.2 Strlen() 3.3 Strcmp() 3.4 Strcat() 3.5 Strcpy() 3.6 Pattern Matching 3.7 Dynamic Memory Allocation 3.8 Malloc() 3.9 Calloc()

3.10 Realloc 3.11 Freeing Memory Exercises Chapter 4 Sorting and Searching 4.1 Sorting 4.2 Different Sorting Techniques 4.3 Bubble sort Implementation 4.4 Selection sort 4.5 Selection sort implementation 4.6 Insertion sort 4,7 Insertion sort Implementation 4.8 Quick sort 4.9 Quick sort implementation 4.10 Merge Sort 4.11 Merge Sort Example 4.12 Bucket Sort 4.13 Heap Sort 4.14 Comparison Of Different Sorting Algorithms 4.15 Searching 4.16 Linear Search 4.17 Binary Search 4.18 Difference between Linear Search & Binary Search Exercises 5 Chapter 5 Stacks and Queues 5.1 Stack 5.2 Implementation of Stack using Arrays and pointers 5.3 Applications of Stacks 5.4 Queues 5.5 Circular Queue 5.6 Priority Queue 5.7 Dequeue 5.8 Input Restricted Dequeues 5.9 Output Restricted Dequeues 5.10 Applications of Queues Exercises Chapter 6 Linked lists 6.1 Linked List 6.2 Creation of Linked List 6.3 Inserting Node 6.4 Deletion of Nodes 6.5 Doubly Linked List 6.6 Operations on Doubly Linked List 6.7 Circular Linked List

6.8 Circular Doubly Linked List 6.9 Advantages/Disadvantages of Linked List Exercises Chapter 7 Trees 7.1 Tree 7.2 Root 7.3 Degree 7.4 Path length 7.5 Level 7.6 Forest 7.7 Labeled Trees 7.8 Binary Tree 7.9 Application Of Trees 7.10 Binary Tree Operations 7.11 Tree Traversal Methods 7.12 The Binary Search Tree 7.13 Threaded Binary Tree 7.14 Use Of Threaded Binary Tree Exercises Chapter 8 Graphs 8.1 Graphs 8.2 Definition 8.3 Adjacency List Representation 8.4 DFS And BFS 8.5 Depth First Search (DFS) 8.6 Breadth First Search (BFS) 8.7 Shortest Path 8.8 Weighted Graph 8.9 Dijkstra Algorithm Exercises

Chapter I Pointers in C

1.1. What is a pointer?

A pointer is a data type in C, which helps the programmer to access the memory locations of variables directly. A pointer contains a memory address which is the address of a variable. So, we define a pointer as follows Definition: A pointer is a variable that contains the address of another variable. We can have a pointer to any variable type. Using pointers complex data types can be declared and accessed efficiently.

1.2 Pointer Declaration: The syntax of declaring a pointer is type *pointerName. The type in the above declaration is called the base type of the pointer. Example: char *x declares x as a pointer to a character variable and int *y says that y is a pointer to an integer variable. When p is a pointer to a variable of integer type, we say that the base type of p is integer. Similarly when q is a pointer to a float variable, we say that the base type of q is float and so on.

After declaring a pointer variable one must assign values to it. That is the pointer must be assigned to some address. We can assign value to pointer in same way as any other variable data type.

int m, n;

int *p,*p1; P=&m;

Here the memory address of variable m is assigned to a pointer variable p. We are getting the address location of the variable, not the content of the pointer variable.

Sum =*p1; Here the content of the pointer variable p1 is assigned to the variable sum. That is, value of p1 is the address of the integer variable sum.

Figure 1.1 A pointer to p1 to an integer variable sum

Program to display the address and contents of a pointer is given next.

Program1.1
#include<stdio.h> void main() { int x;

int *p; // Here A pointer variable of base type integer is declared x=50; p=&x; //The pointer variable p is assigned the address of x printf(Value of x is %d\n,x); printf(Value of the variable pointed by p is %d\n,*p); printf(Address of x is %d,p); getch(); }

Output of the program Value of x is 50 Value of the variable pointed by p is 50 Address of x is 43522

1.2. Pointer Arithmetic

C language supports four arithmetic operations on pointers.

Addition + Subtraction Incrementation ++ Decrementation - -

Here ++ increments the pointer to the address of the next memory location of the same type variable. The increment is done not by one but by the number of bytes required for the data type. That is if an integer is 4 bytes, ++ will increment an integer pointer by 4 and not by 1. Similarly for other operators. Also subtraction of a pointer p2 from a pointer p1 is defined only if p1 and p2 are pointers of the same base type.

Program illustrating pointer operations

Program1.2 #include <stdio.h> void main() { int v,w ,*p,*q; v=80; w=90; p=&v; q=&w; printf("Value of p before increment operation=%u \n",p); p++; printf("Value of p after increment operation=%u\n",p); p--; printf("Value of p after decrement operation=%u\n",p); printf("Value of q=%u\n",q); printf("Value of p-q=%u\n",p-q); } Output of the program Value of p before increment operation=4276350260 Value of p after increment operation=4276350264 Value of p after decrement operation=4276350260 Value of q=4276350256 Value of p-q=1 1.3. Accessing Variables Using Pointer

In C you can see two type of unary operators for declaring a pointer type variable. They are listed below, Address operator & Dereferencing operator *

1.4. Address Operator(&)

Address operator can be represented by the combination of &(ampersand) with a pointer variable .Ampersand is a unary operator that returns memory address to its operand. For example: p =&x;

The pointer operator & returns the address of the variable following it. So we can say that p is assigned the address of x.

1.5. Dereferencing Operator(*)

This can be represented the combination of *(asterisk) along with the variable. Asterisk should be before the variable name. It is also a unary operator that returns the value of the variable located at the address. For example: a=*p; Here a gets the value pointed by the pointer p.
1.5.1.1.1.1.

One and Two Dimensional Arrays Using Pointers

Pointers and arrays are equivalent in the following sense. The name of the array acts as a pointer to the first element of the array. Let us explain this with two examples: int a [50]; The above statement declares an array of integers of size 50, having elements a[0], a[1] ,.., a[49]. This is a one dimensional array. The variable a can be used as a pointer to the array. Variable a will point to the starting address of the array, that is a [0]. The elements of this array are a [0], a[1], , a[49]. They are integer variables. Logically, these elements are stored in 50 consecutive memory locations. Therefore a pointer variable of base type integer can point to these elements. We know that int *ip declares ip as an integer type pointer. Now the two statements below, taken together are equivalent to the statement a[3] = 7 ip = &a[3]; *ip = 7; taken together are equivalent to the statement a[3] = 7

Also the statement ip = a is equivalent to saying that ip = &a[0]. Similarly, ip = a+5 is equivalent to saying that ip = &a[5].Generalizing ,We can say that the following is true.

If a is an array of size n, having elements a[0], a[n-1], of a particular data type, then a is a

pointer of that base type whose value is the address of a[0] and a+k points to a[k] for any k between 1 and n-1. A two dimensional array can be represented by a matrix.The next figure shows a two-dimensional array

Figure 1.2 A two dimensional array b[3][4] with three rows and four columns. The following statement declares a two-dimensional array. float b[3] [4].

C treats a two dimensional array as a one dimensional array of rows. Each row itself is again a one dimensional array.

Now b will point to b[0],which is the first row of the array. Also b+1, b+2, .. Will be used to access to successive rows of the array b[ ][ ].Now b[0], is the first row .Since the first row is a one dimensional array, b[0] is a pointer to the first element b[0][0] of that array . Similarly b[1] is a pointer to the first element b[1][0] in the second row and so on. Also b[0]+j is a pointer to b[0][j]. Again *(b+i) is actually same as b[ i ] and *(*(b+i)+j) is the pointer representation of b[i][j].

Program to display the content of a one dimensional array using pointers: Program1.3

#include<stdio.h> main() { int a[4]={1,2,3,4}; int *p1; int i,s,t1; s=4; printf("Display the contents of array\n"); for(i=0;i<=s-1;i++) { t1= *(a+i) ; printf("value is =%d\n",t1); } }

Output of the program Display the contents of array value is =1 value is =2 value is =3 value is =4

Program to show contents of two dimensional array using pointers

Program1.4 #define maxsize 50


#include<stdio.h> void main() { int b[maxsize][maxsize],n_of_rows, n_of_cols, i,*p, j, tvalue; printf("Enter The number of rows: "); scanf("%d",&n_of_rows); printf("Enter the number of columns: "); scanf("%d",&n_of_cols); for(i=0;i<=n_of_rows-1;i++) { for(j=0;j<=n_of_cols-1;j++) { printf("Enter the (%d,%d) element ", i,j); scanf("%d",&b[i][j]);

} } printf("Contents of array\n"); for(i=0;i<=n_of_rows-1;i++) { for(j=0;j<=n_of_cols-1;j++) { tvalue=*(*(b+i)+j); printf("%d\t",tvalue); } printf("\n"); } } Output of the program Enter The number of rows: 3 Enter the number of columns: 4 Enter the (0,0) element 1 Enter the (0,1) element 2 Enter the (0,2) element 3 Enter the (0,3) element 4 Enter the (1,0) element 5 Enter the (1,1) element 6 Enter the (1,2) element 7 Enter the (1,3) element 8 Enter the (2,0) element 9 Enter the (2,1) element 10 Enter the (2,2) element 11 Enter the (2,3) element 12 Contents of array 1 2 3 4 5 6 7 8 9 10 11 12

1.7 Void Pointers

Pointers to different data types are considered different. There is no implicit conversion from one type of pointer to the other. In order to overcome this inconvenience, we use a pointer to point to multiple data types. If we dont know what kind of value a pointer will point to then we can declare a void pointer. V oid pointers are commonly used in the parameter list of builtin function, such as memcpy and memset. V oid pointer can point to any data type and any other pointer can be assigned to it. But it is not considered good practice to use a void pointer unless it is required in very special cases.

1.9 Pointers in Function arguments

In function declaration you can use pointers frequently. Using pointers as arguments, we can easily rewrite a complex function. Pointer arguments enable a function to access and change variables that are passed to it. Program illustrating the use of pointers in functions. Program1.5

#include<stdio.h>

void main() { int value1,value2; value1=100; value2=200; clrscr(); printf(values before swap()operation is %d%d\n\n, value1, value2); swap(&value1,& value2); //Calls function printf(values after swap()operation is %d %d\t\n\n, value1, value2); getch(); return(0); } void swap(int *value1,int *value2) { int tempvalue; tempvalue=* value1; *value1=*value2; *value2=tempvalue; } Output of the program values before swap() operation is100 200 values after swap() operation is 200 100

1.10 Recursion

Definition: Recursion is a technique widely used to make write complex functions in a simple way. A function which invokes itself directly or indirectly is called as recursive function.

Example: The Factorial of an integer n>=1 is defined as follows

n! = 1 * 2 * , . .*n We can use this definition to write int factorial1 (int n) { int i; int s; s = 1; for (i = 1; i <= n; i++) { s = s * i; } return s; } Using recursion we can rewrite the above function. We know that n!=(n-1)!*n for n >0 . So we can rewrite the above function using follows:

int factorial2 (int n) { If (n<=1) return 1; return n * factorial2 (n - 1)); } This function is an example of implementing recursion in C. Comparing the two problems, the second version is much simpler than first.

There are two types of recursion: 1. Direct Recursion 2. Indirect Recursion

1.11 Direct Recursion

A directly recursive function is a function which contains a direct call to itself. For example, consider the function:

int f1 (int n) { if (n <= 0) return n; return (n+ f1(n- 1)); } The above function contains a call to itself, and so its directly recursive. 1.12 Indirect Recursion

A function f1 is indirectly recursive if it contains a call to another function which in turn calls f1 . The following functions are indirectly recursive. int f1(int n) { if (n<= 0) return n; return (n+ f2(n)); } int f2(int m) { return f1(m - 1); } Here function f1 calls another function f2, which in turn calls the first function f1. So we say that this function is indirectly recursive.

1.13 Array of Pointers

When you have a large array of data items, names for example, and you want to access them in sorted order one method is to use an array of pointers. We can use array of pointers like any other array. The declaration for an integer pointer array p1 of size 15 is

int *p1 [15]; The elements of above array are p1 [0], p1 [1],...,p1 [14], all of them pointers of base type integer.

An array of pointers can be defined in such a manner that each item of the array point to an item in the data array. We will illustrate this with a figure.

Rajesh

Suresh

Aneesh

Hridaya

Joseph

Fransis

Kannan

Now A is the array of pointers, pointing to the data array B. Instead of sorting B in alphabetical order, we just sort A in the alphabetical order of elements of B and access elements of B from elements of A. This type of sorting has the following advantages. 1. The original data is not changed 2. We save time, because sorting of pointers is simple, compared to sorting of strings. 3. No additional space required.

Program illustrates the use of array of pointers. Program1.6

# include<stdio.h> main() { Char *p [4]; p[0]=Sunil; p[1]=Raj; p[2]=Alok; p[3]=Syam;

Printf (content of pointer 1 is=%s\n, p [0]); Printf (content of pointer 2 is=%s\n,p[1]); Printf (content of pointer 3 is=%s\n,p[2]); Printf (content of pointer 4 is=%s\n,p[3]); getch(); }

Output of the program content of pointer is 1=Sunil content of pointer is 2=Raj content of pointer is 3=Alok.

1.14 Pointer to Pointer

A pointer to pointer is a form of multiple indirections. The first pointer holds the address of the second pointer and the second pointer points to a variable.

Pointer pointer Variable.

The general Syntax for the declaration: <Data type> **<pointer name> Eg: int **p1; Program illustrates the use of Pointer to Pointer

Program1.7

#include <stdio.h> main() { int v; int *p1,**p2; v=50; printf("number is =%d\n",v); p1=&v; p2=&p1; printf("address of the number is = %u\n",&v); printf("value pointed by pointer2 =%u\n",*p2); printf("value of pointer1 =%u\n",p1); printf("Value pointed by pointer1=%d\n",*p1); printf("Value pointed by the pointer pointed by pointer2=%d\n",**p2); }

Output of the program number is =50 address of the number is = 4277627172 value pointed by pointer2 =4277627172 value of pointer1 =4277627172 Value pointed by pointer1=50 Value pointed by the pointer pointed by pointer2=50

1.15 Pointers to strings

String operations in c are mainly performed with the help of pointers. String is a sequence of characters; string is accessed in a strictly sequential manner. That is why we use pointers in string operation. String always terminated by a Null character or \0. The following program is an example Program for pointers to strings

Program1.8 #include<stdio.h> #define maxsize 60 void main() { char s[maxsize]; printf(enter the string:); gets(s); display(&s);// calls the function printf(\n); getch(); } void display(char *s) { while(*s!=\0) { printf(%c,*s); s++; } }

Output of the program

enter the string: pointers to string pointers to string

Pointer to Functions Just like any other variable,a function is also stored at a memory location and has an address. The name of the function is a pointer to it. We can also declare pointer to a function.

The following program illustrates an example for function pointer.

Program1.9

#include <stdio.h> void sampleFunction(int n) { printf( "%d\n", n ); } int main() { void (*pointer_to_function)(int);//Declaring a function pointer pointer_to_function = &sampleFunction;//Intitialising the function pointer pointer_to_function( 10 );// calling the function using the function pointer getch(); return 0; } Output of the program 10

Exercises

1. Explain the pointer declaration in C language. 2. How do you declare a pointer to a function? 3. Explain dereferencing operator. 4. What is a void pointer? 5. How can we access a one dimensional array using pointer? 6. Explain pointers to strings. 7. Explain the different types of recursion. 8. Explain pointer arithmetic with example. 9. How can you create array of pointers? 10. Explain about addressing and dereferencing operators.

Chapter II Structures And Unions


2.1 Definition A structure is used to represent a related group of items. Each individual item in the structure is called as a member. Example: struct employee { char empName[10]; char address[20] ; char place[10]; int pinCode; } emp1;

Declares a structure variable emp1 of the type employee. Also the same declaration can be written as struct employee { char empname[10]; char address[20] ; char place[10]; int pincode ; }; struct employee emp1;

Also the type definition can be used to define a structure.

2.2Accessing the members of a structure

To access the members of a structure the . operator is used. Example: emp1.empname will refer to the empname field in the structure variable

emp1.

2.3 Array of structures

Suppose you want to store the details of 100 students in an array. Each student has a roll no. and name and the structure student is defined as, struct student { int Roll no; Char Name[20]; }; Now you can declare an array of size 100 as shown below: Student NRoll [100]; Each element of the array can be the details of the student. That is an array of structures can be used just like an ordinary array, to store data having structure.

Program illustrates the use of array of structures. Program2.1 #define max 3 #include<stdio.h> void main () { structure student { char name[20]; int Rollno; }; struct student class[max]={{Ramya,23},{Sita,45},{Geeta,47}}; int i; printf(List out the contents of Structure\n); for(i=0;i<=max-1;i++) { printf(name:%s\n,class[i].name);

printf(Roll no:%d\n,class[i].Roll no); } } Output of the program List out the contents of Structure Ramya 23 Sita 45 Geeta 47 2.4 Structures Within Structure (Nested Structure) Definition: A structure having another structure as a member is called a nested structure.

A member of structure may be another structure. When a structure is declared as the member of another structure we call it as nested Structure. Using this feature we can build complex structures.

Example: struct date { int day; int month; int year }; struct student { char name[20]; int roll no; struct date dob; };

2.5 Pointer to Structures

We can declare pointers to structures the same way we declare any other pointers: by preceding the variable name with an asterisk in the declaration. struct Complex { int x; float y }; struct complex *p1,*p2; In the above declaration p1, p2 are pointer variables holding the address of a variable of type structure complex.

2.6 Structure in Functions

We can pass a structure variable as a parameter to a function just as we pass any other variable. The following program is an example for passing a structure as a parameter to a function. Program2.2

#include<stdio.h> struct dob //Declaring a structure { int day; int month; int year; }; void main() { struct dob d1; //Declaring a structure variable d1.day=26; d1.month=8; d1.year=2007; display(d1); getch(); }

void display (struct dob n); { printf(date is%d/%/d/%d\n,n.day,n.month,n.year); } Output of the program date is 26 /8/ 2007

2.7 Unions

We have a situation where we want to interpret the value of a variable depending upon the context of the variable. Union stores values of different data types in a single location. This saves memory. Declaration and usage of union is same as that of structure with the keyword struct replaced by the keyword union.

For example a merchant may sell items by number or by weight (example: two bottles of squash and 3.5 k.g sugar).In this case the field quantity sold can be taken as a union of an integer and a float. . Declaration union quantity { int no_of_items; float weight; };

struct saledetails { int type; union quantity quantity_sold; };

Program to illustrate union

Program 2.3

#include<stdio.h> typedef union { int trucknumber; char truckname[8]; }load;

typedef struct { char itemname[10]; load item; }goods;

int main() { goods gd[10]; int i,n; printf ("Enter no of shipping items\t"); scanf("%d",&n); for (i=0; i<n; i++) { printf("Enter the itemname ,trucknumber\t"); scanf("%s",gd[i].itemname); scanf("%d",&gd[i].item.trucknumber); } for (i=0;i<n;i++) { printf("\nItemname=%s",gd[i].itemname); printf("\nTruckNumber=%d",gd[i].item.trucknumber); } printf("\n");

for (i=0; i<n; i++) { printf("Enter the truckname\t"); scanf("%s",gd[i].item.truckname); } for (i=0;i<n;i++) { printf("\nTruckname=%s",gd[i].item.truckname); printf("\nTruckNumber=%d",gd[i].item.trucknumber); } getch(); return 0;

} Output of the Program Enter no of shipping items 2 Enter the itemname ,trucknumber Steel 5678 Enter the itemname ,trucknumber Nickel 6665

Itemname=Steel TruckNumber=5678 Itemname=Nickel TruckNumber=6665 Enter the truckname Bangar Enter the truckname Star7

Truckname=Bangar TruckNumber=1735287106 Truckname=Star7 TruckNumber=1918989395

In the above program you can see that when we try to print the truck number after reading truck name it is showing some unknown value. This is because the same space is used for storing truck number and truck name. So truck name overwrites the truck number.

2.8 Difference and similarity between structure and union

The differences between structure and union in c are:

3. Union allocates the memory equal to the maximum memory required by any member of the union, but structure allocates the memory equal to the total memory required by all the members.

2. In union, one block is used to store all the members of the union. That is, all the members share same memory. In the case of a structure, each member has their own memory space.

The similarities between structure and union are

2. Their declarations have similar syntax. 2. Accessing members also have the same syntax (using the . Operator) 3. Structures as well as unions can be nested inside other structures or unions.

Exercises

1. Explain the declaration and initialization of structures. 2. Explain structure within structure. 3. Explain the use of pointers in structure. 4. Explain union. 5. What is the difference between structure and union? 6. What you mean by array of structure? 7. Develop a c program to read the following information from the key board Employees name Employees code Age designation and represent it as a structure.

Chapter III Strings and String Operations


3.1 Strings In C, a string is viewed as an array of characters. A special character called null denoted by \0 ends the string. The following is an example of a string stored as an array of characters. I L O V E I N D I A \0

C provides for many strings operators. Let us discuss the following in detail.

Function strlen

Parameters String

Use Length of string

strcat String1, string 2 Concatenate of string 2 to 1 strcmp String 1, string2 Compare two strings

strcpy String 1, string2 Copy string 2 to string 1

3.2 strlen ( )

We are using strlen() for knowing the length of the string. The strlen ()checks each array position to see whether it is null or not. N=strlen (string); Sample program to check the length of the string is given below Program 3.1

#include < stdio.h > #include < string.h> void main() { char name[100]; int length; printf(Enter the string=); gets(name); length=strlen(name); printf(\nNumber of characters in the string is=%d,length); }

Output of the program Enter the string= Geetha Number of characters in the string is=6.

Implementation of string length operations using user-defined functions is as follows.

int strlen(char s1[ ]) { int k; for(k=0;s1[k]!=\0;k++) { continue; } return(k); }

3.3 strcmp()

This function is used to compares two strings. This function returns value 1 if the two strings are same and it will returns 0 otherwise. This is one of the most commonly used of the string handling functions. Example: strcmp(char *a1, char *a2);

Implementation of string comparison operations using user-defined functions is as follows.

int strcmp(char a1[ ], char a2[ ]) { int j,j1,j2; j1=strlen(a1); j2=strlen(a2); if (j1!=j2) return(0); for(j=1;j<j1,j++) { if(a1[j]!=a2[j]) return(0); } return(1); }

3.4 strcat() strcat (string1,string2) string1 and string2 are strings. When the function strcat is executed string2 is appended to string1. The string at string2 remains unchanged.

strcpy (string1,sri); strcat (string2,devi); printf (%s,strcat(string1,string2); From the above program segment the value of string1 becomes sridevi string at str2 remains unchanged as devi.

The following shows the implementation of strcat as a program

Program3.2

#include<stdio.h> void main() { char s1[10 ],s2[10 ],s3[30]; int k=0,k1; printf("Enter the first string\n"); gets(s1); printf("Enter the second string\n"); gets(s2); for(k=0;s1[k]!='\0';k++) s3[k]=s1[k]; k1=k; k=0;

for(k=0;s2[k]!='\0';k++) s3[k1+k]=s2[k]; k1=k1+k; printf("The concatenated string is given below\n"); for (k=0;k<k1;k++) printf ("%c",s3[k]); getch(); }

Output of the program

Enter the first string Good morning Enter the second string India The concatenated string is given below Good morning India

3.5.strcpy()

This is used to copy one string to another char *strcpy(char *s4, char *s5); Copy the string pointed to by s5 into the string pointed to by s4,

C does not allow you to assign the characters to a string directly as in the statement Name=sandya; instead use strcpy like this strcpy (Name,sandya); In the above example sandya is assigned to the string called Name .

Implementation of string comparison operations using user-defined functions is as follows.

void strcpy(s,s1) { int k; char s[],s1[]; for(k=0;s1[k]!=\0;k++) { s1[k]=s[k]; }

s1[k]=\0; }

3.6 Pattern Matching Pattern matching in strings is the process of checking whether a given pattern of letters (string) occur as a substring in a given string. Here we have two inputs the given string, and the pattern string. Clearly the length of the pattern should not exceed the length of the given string.

3.7 Dynamic Memory Allocation

The C compiler needs to allocate memory to variables. This Memory allocation can be classified into two types.

1. Static or compile time and 2. Dynamic or run time.

In static memory allocation memory required for a variable is allocated at the time for compilation. For example, if you declare x as a float variable by float x; Then the memory required for x is the size of a float and allocated at the time of compilation. Similarly if you want to declare an array of 10 integers by int a [10]; Then 10 times size of an integer is reserved at the compile time. This has the following disadvantages. 1. You cannot use more memory than what you have already allocated. 2. If you use less memory than allocated, the remaining memory is wasted. This causes inefficient use of memory. Dynamic memory Allocation allocates memory at run time. The following functions are used in C to do the dynamic memory allocation. malloc, calloc, realloc, free.

3.8 Malloc

This function is used to allocate a heap of storage. The name stands for memory allocation. The general declaration of malloc function, char *malloc (size) int size; The following program segment illustrate the use of malloc function struct linkedlist { int value struct linkedlist *value; }; struct linkedlist *pnode; pnode=(struct linkedlist*)malloc (sizeof(struct linkedlist)); 3.9 Calloc Calloc is used to allocate contiguous memory on an element-by-element basis. The name stands for calculated allocation. This is useful in the case of array like structure where continuity of memory required. void calloc(elements, element_size); Thus to assign 500 integer elements that are all initially zero you would do:
int *pnode; pnode = (int *) calloc(500, sizeof(int));

The following program illustrates the dynamic allocation of arrays using calloc Program 3.3 #include<stdio.h> int main() { int *array,n,i; printf("Enter the size of array\t"); scanf("%d",&n); array=(int*)calloc(n,sizeof(int)); printf("Enter %d numbers\n",n); for(i=0;i<n;i++) scanf("%d",&array[i]); printf("Numbers Entered \n"); for(i=0;i<n;i++)

printf("%d\t",array[i]); getch(); return 0; }

Ouput of the Program Enter the size of array 10 Enter 10 numbers 19 29 39 495 96 97 98 90 80 79 Numbers Entered 19 29 39 495 96 97 98 90 80 79

3.10 Realloc Realloc is a function which attempts to change the size of a previously allocated block of memory. (Realloc stands for reallocate) The new size can be larger or smaller. If the block is made larger then the old contents remain unchanged and memory is added to the end of the block. If the size is made smaller then the remaining contents are unchanged The general declaration for the realloc function is given below char *realloc (oldblocksize,newblocksize) int oldblocksize; int newblocksize;

3.11 Freeing Memory

Memory allocated with malloc lasts as long as you want it. When you have finished using a portion of memory you should always free(deallocate) it. If you want to deallocate the memory that allocate by malloc function call, we can use function free (). The general declaration for free () function is given below int free (pnode) char *pnode;

The following program illustrates the use of malloc( ) to allocate some bytes then use realloc( ) to allocate more bytes and finally use free( ) to deallocate the allocated bytes.

Program 3.4

#include<stdio.h> int main() { char *p,size,newsize; printf("Enter the size\t"); scanf("%d",&size); p=(char *)malloc(size); //allocating size bytes to character pointer p. printf("Enter a string of length %d\t",size); getchar(); gets(p); puts(p); printf("Enter the new size\t"); scanf("%d",&newsize); p=realloc(size,newsize); //reallocating newsize bytes to character pointer p. printf("Enter a string of length %d\t",newsize); getchar(); gets(p); puts(p); free(p); //deallocating memory. printf("Memory is deallocated\n"); getch(); }

Output of the program Enter the size 5 Enter a string of length 5 abcde abcde Enter the new size 7 Enter a string of length 7 abcdefg abcdefg Memory is deallocated

Exercises

1. How we are using pointers to handle strings? 2. What are the different string handlings functions? 3. Write a c program to find out the length of a string. 4. Write a C program to print the string abbreviation of an inputted string. 5. Explain the different types of memory allocation. 6. What is the disadvantage of static memory allocation ? 7. Explain Dynamic memory allocation. 8. What are the advantages of dynamic memory allocation? 9. How can you change the size of previously allocated memory? 10.How can you deallocate a memory?

Chapter IV Sorting and Searching


4.1 Sorting

Sorting is arranging data items in some order. For example, we may want to arrange 10 numbers in ascending (increasing) order, or a teacher may need to arrange a list of students in alphabetical order, or he may want to arrange the marks of students in descending (decreasing)order. For all such purposes we use sorting. Example: The numbers 9,10,5,6,3,8 when sorted in ascending order becomes 3,5,6,8,9,10, and when sorted in descending order, they are arranged as 10,9,8,6,5,3. There are two types of sorting 1. Internal sorting. 2. External sorting. 1. Internal sorting: This means data for sorting is available in memory. 2. External sorting: Some times it happens that data item for sorting is too large to occupy in memory. So we need to store such items in secondary storage devices then we have to apply external sorting.

4.2 Different Sorting Techniques

1. Bubble sort It is the oldest and simplest sorting technique. In bubble sort pairs of adjacent values are sorted by comparing the values with each other. Therefore an item bubbles the entire list, until it reaches one value that compare to be smaller than the first value. Suppose we have an n number of elements in our list to sort, then we have to do (n-1) passes (iterations). Advantages: Bubble sort is simple and easy to implement.

Disadvantages: For n no of elements there will be n-1 iterations. So Bubble sort is considered as the most inefficient sorting algorithm.

Best case: Under best case if array is already sorted then also the outer loop to execute n-1 times. Time complexity for best case is O (n ).
2

4.3 Bubble sort implementation

In order to explain bubble sort we are taking an array of three items. This is shown below.

a[0] 160

a[1] 155

a[2] 120

3. In first iteration i=0, 0th element 160 is compared with 155. Since 160 is greater than 155, we interchange them. Resulting array is 155,160,120. Now 160 is in a[1]th position. It is compared with the a[2].120 is less than 160, so we interchange them. Array is now 155,120,160 2. For the second iteration 0th element 155 is compared with first element. Here 120 is less than 155, so we interchange them. Resulting array is 120,155,160.Now 155 is in a [1], it is compared with a[2].155 is less than 160,we cannot interchange them. Now the array is in its sorted order. Resulting array is 120,155, 160.

a[0] 120

a[1] 155

a[2] 160

Program for bubble sort: Program 4.1 #include<stdio.h> #include<conio.h> void main() { int i,j,n,array[5],tempvalue=0; printf("Enter the size\n"); scanf("%d",&n); printf("Enter %d numbers\n",n); for(i=0;i<n;i++) { scanf("%d",&array[i]); } for(i=0;i<n;i++) { for(j=0;j<n-1;j++) { if(array[j]>array[j+1]) { tempvalue=array[j]; array[j]=array[j+1]; array[j+1]=tempvalue; } } } printf("The list sorted in ascending order is\n"); for(i=0;i<n;i++) { printf("%d\n",array[i]); } getch(); }

Ouput of the Program Enter the size 5 Enter 5 numbers 99 77 88 66 55 The list sorted in ascending order is 55 66 77 88 99 4.4. Selection sort In selection sort we are taking the smallest item (unsorted) in the list, and swapping it with the item in the very next position. Suppose we want to sort the given numbers in ascending order, 0th element is compared with other elements present in the list, .If the 0th element is greater than the compared element then they are interchanged. After the first iteration the smallest element is placed in 0th position. Similar procedure is repeated for the entire list of elements. Advantages: Simple technique and easy to implement. Disadvantages: Inefficient for large list of elements. Program for selection sort 4.5 selection sort implementation We can explain the selection sort by taking an array of 4 items.

a[0] 250

150 a[1]

a[2] 200

a[3] 100

2. For the first iteration i=0, 0t h element is compared with a[1]. 150 is less than 250, we interchange them. Resulting array is 150 250 200,100.a[0]t h element is again compared with a[2]th element, which is greater than a[0]th element so we cant interchange them. Again 150 compared with a[3].100 is less than 150, we interchange them. The resulting array is 100,250,200,150. 3. For the second iteration i=1, a [1] th element compared with a [2]. 200 is less than 250, we interchange them. Resulting array is 100,200,250,150. th a [3] element compared with a[1]. 150 is less than 200, we interchange them. Resulting array is 100,150,250,200. 3. For the third iteration i=2,250 is compared with a [3]. 200 is less than 250 we interchange them. Resulting array is

a[0] 100

150 a[1]

a[2] 200

a[3] 250

Program for selection sort Program 4.2

#include<stdio.h>

void main() { int array[12],i,n,smallvalue,j,position,tempvalue; printf("Enter the size\n"); scanf("%d",&n); printf("enter %d elements\n",n); for(i=0;i<n;i++) scanf("%d",&array[i]); for(i=0;i<n-1;i++) { smallvalue=array[i]; position=i; for(j=i+1;j<n;j++) { if(array[j]<smallvalue) { smallvalue=array[j]; position=j; } } tempvalue=array[i]; array[i]=smallvalue; array[position]=tempvalue; } printf("\n Sorted array is\n"); for(i=0;i<n;i++) { printf("%d\n", array[i]); } getch(); }

Output of the Program

Enter the size 5 enter 5 elements 99 66 33 88

77

Sorted array is 33 66 77 88 99

4.6. Insertion sort Insertion sort is a simple sorting algorithm, in which the sorted array (or list) is built one entry at a time. The insertion sort works just like its name; it inserts each item into its proper place in the list. We use two lists to implement insertion sort. The insertion sort has a time complexity of O (n ).
2

Advantage: Comparatively simple and it is easy to implement. Disadvantage: Inefficient for large lists.

4.7. Insertion sort implementation

Here we have an array a[3], consists of 3 elements. We can see how insertion sort is going to implement for sorting numbers in ascending order.

a[0] 160

a[1] 152

a[2] 100

1. For the first iteration i=1, a[1] is compared with a[0].we have found that 152 is less than 160, we

interchange them. 2. For the second iteration i=2, the second element 100 is compared with 160. Then we interchange them.100 is again compared with 152. The resulting Array is shown below. a[0] 100

a[1] 152

a[2] 160

Program for Insertion sort: Program 4.3

#include<stdio.h> void main() { int array[12],i,j,n,tempvalue; printf("Enter the size of numbers to sort\n"); scanf("%d",&n); printf("enter %d numbers\n",n); for(i=0;i<n;i++) scanf("%d",&array[i]); for(i=1;i<n;i++) { tempvalue=array[i]; j=i-1; while((tempvalue<array[j]&&(j>=0))) { array[j+1]=array[j]; j=j-1; } array[j+1]=tempvalue; } printf("Sorted array is \n"); for(i=0;i<n;i++) printf("%d\n",array[i]);

getch(); } Output of the Program Enter the size of numbers to sort 5 enter 5 numbers 99 22 55 77 44 Sorted array is 22 44 55 77 99

4.8Quick sort

The quick sort is one of the fastest sorting techniques. Quick sort is an algorithm using recursion. There are four steps in the algorithm. If there are no elements or just one element in the array to be sorted, return immediately. 1. Select an element in the array as a pivot point. Mainly we are taking the leftmost element in the array 2. Split the array into two parts - one with elements larger than the pivot and the other with elements smaller than the pivot. 3. Repeat the algorithm for both halves of the original array. The efficiency of the algorithm mainly depends upon which element is chosen as the pivot element. The worst-case efficiency of the quick sort, O (n ), occurs when we have taken the left-most element. As long as the pivot point is chosen randomly, the quick sort has its algorithmic complexity of O (n log n). Advantage: Extremely fast one. Disadvantage: Very complex algorithm and highly recursive one.
2

4.9 Quick sort implementation We can explain the Quick sort by the following example. We have an array of 7 Elements.

a[0] 56

12 a[1]

a[2] 25

a[3] 33

a[5] 100

a[6] 70

a[7] 80

There are a number of ways to pick the pivot element. In this example, we will use the first element in the array as pivot element. Given a pivot, partition the elements of the array such that the resulting array consists of: 3.1. One sub-array that contains elements >= pivot 3.2. Another sub-array that contains elements < pivot

56 12 25 33 100 70 80

Quick sort starts with 0th element 56. Read the elements from right to left. Compare element with 56 on starting from right to left. Stop at the element which has less value of that 56. The number is 33, we interchange them. Resulting array look like this

33 12 25 56 100 70 80.

We take 56 as the Pivot element. Because the elements of the array to left are smaller than 56; elements of the array to right are greater than 56. Here we are dividing the array into two parts, one is right side of 56, other one is left side of 56.The above procedure is repeated for the two sub arrays, until we get the sorted array. Program for Quick sort Program 4.4 #include<stdio.h> int main() { int array[30],n,i; printf("\nEnter size of the array :"); scanf("%d",&n); printf("Enter %d elements : ",n); for(i=0;i<n;i++) // reading elements scanf("%d",&array[i]); quickSort(array,0,n-1);// function to sort printf("\nSorted elements :"); for(i=0;i<n;i++) printf(" %d",array[i]); getch(); return 0; }

quickSort(int array[10],int left,int right) { int pivot,j,temp,i; if(left<right)

{ pivot=left; //choosing first element as pivot i=left; j=right;

/*Considering the pivot element array is subdivided into two arrays*/ while(i<j) { while(array[i]<=array[pivot]&&i<right) i++; while(array[j]>array[pivot]) j--; if(i<j) { temp=array[i]; array[i]=array[j]; array[j]=temp; } } temp=array[pivot]; array[pivot]=array[j]; array[j]=temp; quickSort(array,left,j-1); //applying quick sort to left sub array quickSort(array,j+1,right); //applying quick sort to second sub array } }

Output of the program

Enter size of the array :10 Enter 10 elements : 88 55 99 22 44 66 11 43 57 21 Sorted elements : 11 21 22 43 44 55 57 66 88 99

4.10. Merge Sort


Merge sort is another sorting algorithm which works in the following way. 3. Divide the element in to two parts. 4. Sort the two parts using merge sort algorithm 5. Merge the two sorted list in to a single sorted list. The heart of a merge sort algorithm is a procedure to merge two sorted list in to a single sorted list. The time complexity of the algorithm is O(nlogn). Advantage: Marginally faster for larger sets. Disadvantage: At least twice the memory requirement of the other sorts:

4.11 Merge Sort Example Consider an array of 4 integers 7,3,5,4. Now merge sort first divides the array in to two sub array [7,3], and [5,4].In the next step[ 7,3] and [5,4 ] are divided in to [7]&[3] and [5]&[4].Now these two are merged back to form[3,7] and[4,5], which is again merged to form 3,4,5,7. The below figure explains the idea.

Program for Merge sort Program 4.5 #include<stdio.h> #define maxsize 50 void merge( int array1[maxsize],int start1,int end1, int end2) { //merges two sorted sub arrays array1[start1],..., array1[end1] and //array1[end1+1]... // array1[end2] into a single sorted array.

int size1,size2,size3, index1,index2,index3, index4,i,j; int result[maxsize]; //A temporary array to store the result index1=start1; index2=end1+1; index3=start1; index4=start1; while((index1<=end1)&&(index2<=end2)) if(array1[index1]<array1[index2]) //If an element in the first subarray // is lesser,move it to the result array { result[index3]=array1[index1]; index1++; index3++;

} else { result[index3]=array1[index2]; //otherwise move the element of //the second part to the result array index2++; index3++; } if(index1>end1) //first part is over. // So copy the second part to the result array while(index2<=end2) { result[index3]=array1[index2]; index2++; index3++;

} else //second part is over while(index1<=end1) { result[index3]=array1[index1]; index1++; index3++; } for(index4=start1;index4<=end2;index4++) //copy the result array to //corresponding positions in the original array { array1[index4]=result[index4]; } } void mergesort(int data[maxsize],int start,int end)//sorts elements from positions //start to end in an array using merge sort { int mid; if(start<end) { mid=(start+end)/2; mergesort(data,start,mid); //first sort the first half mergesort(data,mid+1,end);//now sort the remaining merge(data,start,mid,end);//merge them } } void main() { //program to sort an array of 10 elements using merge sort int A[maxsize], final,i,result,n; printf("Enter the no. of elements\n"); scanf("%d",&n); result=0; for(i=0;i<n;i++) { printf("Give A[%d]:",i); scanf("%d",&A[i]); } mergesort(A,0,n-1); printf("\nThe sorted Array is\n"); for(i=0;i<n;i++) printf("%d\n",A[i]); getch();

} Output of the Program Enter the no. of elements 7 Give A[0]:12 Give A[1]:45 Give A[2]:89 Give A[3]:32 Give A[4]:1 Give A[5]:4 Give A[6]:55

The sorted Array is 1 4 12 32 45 55 89

4.12. Bucket Sort

Bucket Sort is another approach based on comparing digits. Bucket sort assumes that the range of input is known beforehand .It assumes that the input is uniformly distributed over the range. In this method the range of input is divided in to sub intervals called Buckets and place the input into these buckets. Then these buckets are sorted and listed in order. Program for Bucket Sort Program 4.6 #include <stdio.h> void bucketSort(int array[],int n); int main() { int array [10] = {1,7,4,6,4,2,8,1,2,9};

int n = 10; int i; printf("The array is\n\n"); for (i = 0;i < n;i++) printf("%d ", array [i]); printf("\n"); bucketSort(array, n); printf("The Sorted array is\n\n"); for (i = 0;i < n;i++) { printf("%d ", array [i]); } printf("\n"); getch(); return 0; }

void bucketSort(int array [], int n) { int i, j; int a[n]; for(i=0;i<n;i++) { a[i] = 0; }

for(i=0;i<n;i++) { (a[array [i]])++; } for(i=0,j=0;i<n;i++) { for(;a[i]>0;(a[i])--) { array [j++] = i; }

} }

Output of the Program The array is 1746428129 The Sorted array is 1122446789

4.13. Heap Sort Heap sort uses a heap for sorting. A heap is a type of binary tree. It has two properties. 1. It is a complete binary tree. At each level, except possibly the last level, every node has two children. 2. The value of each node is, greater than or equal to the values of nodes in the children. (This is called the heap property) Algorithm for heap sort contains the following steps: 1. Construct a heap from the array elements. 2. Shift the root element of the heap to the end of the array, and then rebuild the heap structure with the remaining elements. 3. Repeat step 2 until there are no more elements in the heap. The time complexity of heap sort is O(nlogn).

Figure for heap Program for HeapSort Program 4.7 #include<stdio.h> #include<conio.h>

void heapsorting(int [ ],int); void main() { int w[25],i,n; printf("Enter the no of elements to sort\n" ); scanf("%d",&n); printf("Enter %d elements to sort\n",n); for(i=0;i<n;i++ ) scanf("%d",&w[i]); heapsorting(w,n); printf("\nAfter the heap sort\n"); for(i=0;i<n;i++) printf("\t%d",w[i]); getch(); } void heapsorting(int x[ ],int n) { int i,el, s1,f1,evalue; for(i=1;i<n;i++) { el=x[i]; s1=i; f1=(s1-1)/2; while(s1>0&&x[f1]<el) { x[s1]=x[f1]; s1=f1; f1=(s1-1)/2; } x[s1]=el; } for(i=n-1;i>0;i--) { evalue=x[i]; x[i]=x[0]; f1=0; if(i==1) s1= -1;

else s1=1; if(i>2&&x[2]>x[1]) s1=2; while(s1>=0&& evalue<x[s1]) { x[f1]=x[s1]; f1=s1; s1=2*f1+1; if(s1+1<=i-1&&x[s1]<x[s1+1]) s1=s1+1; if(s1>i-1) s1= -1; } x[f1]=evalue; } } Output of the Program Enter the no of elements to sort 7 Enter 7 elements to sort 99 77 33 55 88 22 44

After the heap sort 22 33 44 55 77 88 99

4.18 Compare Different Sorting Algorithms

We have seen different sorting and searching algorithms. Depending up on the types of data and the operation one may perform on data, we are choosing different sorting algorithm. We compare algorithms based on time complexity .The time complexity of algorithm measures the running time of the algorithm compared to the input data.

Time complexity is represented using the O notation. An algorithm is O(n) if the running time is less than or equal to a constant times n. Here n is the size of the input. Similarly an algorithm is O (n ) if its running time less than or equal to a constant time n , and so on. And O(n) algorithm is considered better than O (nlogn) algorithm, which in turn is consider better than an O(n ) algorithm and so on. We can see the time complexity for different algorithms
2 2 2

Algorithm Bubble sort

Worst case Average case O(n2) O(n2) O(n2) O(n2)

Insertion sort O(n2) Selection sort O(n2) Merge sort Quick sort Heap sort

O(n log n) O(n log n) O(n2) O(n log n)

O( n log n) O(n log n)

From the above comparison it is clear that 1. Bubble sort, selection sort and insertion sort have the same time complexity O(n ). Also bubble sort is easy to implement, But is highly inefficient. 2. Quick sort and heap sort have the same average time complexity O(nlogn). So both of them are considered better than Bubble sort, selection sort or insertion sort. The choice of the correct pivot point is important in quick sort, But heap sort guarantees O(nlogn) performance under any condition. 3. Merge sort also works in O(nlogn) time, so it is better than Bubble sort, selection sort or insertion sort ,but it works only when the given lists are already sorted. 4. Bucket sort is an O(n) sorting algorithm, So it can be considered better than other algorithms, but it works only when the numbers are uniformly distributed and range of input known in advance. 5. For smaller input simpler algorithms such as bubble sort may be better, but for larger input algorithms like Quick sort and heap sort are better. Also if the input consists of two sorted lists, merge sort is better. If the input is uniformly distributed and ranges of values are known in advance, bucket sort is better.
2

4.14 Searching

Searching is the process of determining whether a given element is in a list. A search technique will give the position of the element if one is found. Otherwise it will say that element is not found.

4.15. Linear search We also call it as sequential searching. In Linear search searching means a set of data for a particular value .We are the entire list one by one until we get the desired value. This is one of the simplest searching Techniques. Advantage : Good to use for small sets of data. Disadvantage: Suppose the data set is too big, then the searching process will be slower.

Program for Linear search Program 4.8 #include <stdio.h> void main() { int a[10],i,n,position,n1; printf("Enter the size of the array\n"); scanf("%d",&n); printf("Enter the elements\n"); for(i=0;i<n;i++) scanf("%d",&a[i]); printf("Enter the element to search\n"); scanf("%d",&n1); for(i=0;i<n; i++) { if(a[i]==n1) { position=i; printf(" Search Successful :Location at %d", position); break;

} } if(i==n) printf(" Sorry search unsuccessful"); getch(); } Output of the Program Enter the size of the array 7 Enter the elements 33 77 22 99 55 44 88 Enter the element to search 99 Search Successfull:Location at 3

4.16 Binary Search

It is a technique to find out a particular value in a sorted list of items. Binary search is a fast and efficient searching technique. In binary search we are comparing the elements with the element in the middle of the list(mid).we are taking the middle element by taking the first and last element of the list Mid= (beg+last) /2. A fast way to search a sorted array is to use a binary search. We are going to take the element in the middle for seaching purpose. If the element we want to search is equal to mid element, the search is finished. If the element is less than the mid element, we are searching on the first half. If its greater, we are searching at the second half. Advantage: Fast and easy to implement. Disadvantage: Works only on sorted array. Program 4.9 Program for Binary search

#include<stdio.h> void main() { int array[10],i,j,t,begin,end,n,middest,num; printf("Enter the size of the array\n"); scanf("%d",&n); printf("Enter the elements in sorted order\n"); for(i=0;i<n;i++) scanf("%d",&array[i]); begin=0; end=n; printf("Enter the element to search\n"); scanf("%d",&num); while(begin<end) { middest=(begin+end)/2; if(array[middest]==num) { printf("Search is success element found at location at %d", middest); break; } if(num>array[middest]) begin=middest+1; else end = middest-1; } if(begin==end) printf("unsuccessful search"); getch(); }

Output of the program

Enter the size of the array 10 Enter the elements in sorted order 11 22 33 44 55 66 77 88 99 100 Enter the element to search 77 Search is success element found at location at 6

4.17 Difference between Linear Search & Binary Search

5. We use linear search for a small set of values. But we can use Binary search for a large set of values. 6. On comparing with binary search technique linear search is a slower one. 7. Binary search is applicable in the case of sorted elements only. But using linear search you can find out the element from unsorted list. In the case of an unsorted array linear search is the best one.

Exercises

1. Explain different sorting methods. 2. What is external sorting? 3. Define searching. 4. Compare different searching algorithms. 5. What is time complexity? 6. List out the complexity comparison of different sorting algorithms. 7. Explain quick sort. 8. Write a c program for linear search. 9 Write a c program to implement heap sort. 10. Write a c program to implement bubble sort.

Chapter V Stacks and Queues


5.1 Stack Stack is a data structure which uses the principle of Last in first out (LIFO). In stacks we are removing the element that we recently added in to the list. The most recently added item is at the top of the stack. Here insertion and deletion is carried out at one end. Basic stack operations are push and pop. Insertion of elements in to the stack is known as PUSH operation and deletion of elements from stack is known as POP operation. Stack can represented using both an array and a linked list.

Figure 5.1 Different operations on a stack Push : Places an object on the top of the stack Pop : Removes an object from the top of the stack Empty : Reports whether the stack is empty or not.

5.2 Implementation of Stack Using Arrays and pointers Array can be used to represent stacks. On using array limited number of elements can be inserted and deleted. Suppose we have declared an array of stack of size 4 Eg int stack [5], and then we can insert maximum 5 elements, starting from stack [0] to stack [4]. We have a pointer Top which always point to the top element in the stack. Initially we have declared that top as empty, by giving a value (-1).If stack contains single data item top points to stack [0]. When a new element is inserted in to the stacks, top is increments by one. The pointer is decremented by one each time a deletion happens. Also a stack can be implemented using pointers.

Program to implement stacks using arrays Program 5.1

#include<stdio.h> #define Size 4 void pushoperation(); //add item to stack void popoperation(); //delete item from stack void showstack(); //to show stack int stack[Size],Top=-1; void main() { int option; do { printf("Which stack operation you want?\n"); printf("1-PUSH\n2-POP\n3-SHOW\n4.Exit\n"); scanf("%d",&option); switch(option) { case 1:pushoperation(); break; case 2:popoperation(); break; case 3:showstack(); break; } }while(option<4); getch(); }

void pushoperation() //add item to stack

{ int v; if(Top>=Size) printf(" Sorrry not enough space"); else { printf("Please enter the element in to the stack\n"); scanf("%d",&v); Top=Top+1; stack[Top]=v; } }

void popoperation() //delete item from stack

{ int t; if(Top==-1) { printf("Sorry stack is empty"); return; } else { t=stack[Top]; Top=Top-1; printf("%d popped from the stack\n",t); } }

void showstack() //to show stack

{ int i;

if (Top==-1) printf("Stack is empty "); else { printf("Stack contents are..\n"); for(i=Top;i>=0;i--) { printf("%d\n", stack[i]); } } } Output of the program Which stack operation you want? 1-PUSH 2-POP 3-SHOW 4.Exit 1 Please enter the element in to the stack 111 Which stack operation you want? 1-PUSH 2-POP 3-SHOW 4.Exit 1 Please enter the element in to the stack 222 Which stack operation you want? 1-PUSH 2-POP 3-SHOW 4.Exit 1 Please enter the element in to the stack 333 Which stack operation you want? 1-PUSH

2-POP 3-SHOW 4.Exit 3 Stack contents are.. 333 222 111 Which stack operation you want? 1-PUSH 2-POP 3-SHOW 4.Exit 2 333 popped from the stack Which stack operation you want? 1-PUSH 2-POP 3-SHOW 4.Exit 3 Stack contents are.. 222 111 Which stack operation you want? 1-PUSH 2-POP 3-SHOW 4.Exit 4

Program for implementing stack using pointers:

Program 5.2

#include<stdio.h> struct stack { int value; struct stack *link; }; struct stack *pushoperation(struct stack *top,int val); struct stack *popoperation(struct stack *top,int *val); void showstack(struct stack *top);

void main() { struct stack *top; int val,ch; top=NULL; do { printf("\n Menu for stack operation"); printf("\n 1.Add\n 2.Delete\n 3.Show\n"); printf("\nEnter u r choice\n"); scanf("%d",&ch); switch(ch) { case 1: printf("Enter the element to push in to stack\n"); scanf("%d",&val); top=pushoperation(top,val); break; case 2: top=popoperation(top,&val); if(top!=NULL) printf("the deleted value is %d",val); break; case 3: showstack(top); break; }

}while(ch<4); getch(); }

struct stack* pushoperation(struct stack *top,int val) // add item to stack { struct stack *w; w=(struct stack*)malloc (sizeof(struct stack)); w->value=val; w->link=top; top=w; return(top); } struct stack* popoperation(struct stack*top,int *val) // Remove item from stack { struct stack *w; if (top==NULL) { printf(" Sorry stack is empty\n"); top= NULL; } else { w=top; top=top->link; *val=w->value; } return(top); } void showstack(struct stack *top) //Display stack items { struct stack *p1; p1=top; printf("contents of stack is\n"); while(p1!=NULL) { printf("\n%d",p1->value); p1=p1->link;

} }

Output of the Program Menu for stack operation 1.Add 2.Delete 3.Show Enter u r choice 1 Enter the element to push in to stack 222 Menu for stack operation 1.Add 2.Delete 3.Show Enter u r choice 1 Enter the element to push in to stack 333 Menu for stack operation 1.Add 2.Delete 3.Show Enter u r choice 3 contents of stack is 333 222 Menu for stack operation 1.Add 2.Delete 3.Show Enter u r choice 2 the deleted value is 333 Menu for stack operation

1.Add 2.Delete 3.Show Enter u r choice 3 contents of stack is 222 Menu for stack operation 1.Add 2.Delete 3.Show Enter u r choice 4

5.3 Applications of Stacks

Stack is a very useful data structure which finds applications in a variety of areas. They include: Evaluation of arithmetic Expression An arithmetic expression like A+B-C/2 consists of operators like +,-,*and operand which are numeric values or variables like a, b , c in order to convert such an expression to instruction understandable by the computer one has to ,first determine the exact order in which the operators are evaluated. Each operator is given a priority and the expression is evaluated using these priorities. In this evaluation we use the stack to store the different operators and operands. Recursion: During recursion a function calls itself. The values of the variables in the calling function are pushed in to a stack. They are popped out, when the called function returns. n operating systems when a running process A (also called process) passes control to another process B the details of the former process A is kept in the stack.

5.4 Queues

A queue is a linear data structure in which addition of new element takes place at one end called rear. And deletion of existing elements takes place at another end called front. A queue is often called as FIRST IN FIRST OUT (FIFO) structure .

Figure 5.2

Queue Implementation Using Array

Program 5.3

#include<stdio.h> #define size 5 // Size of the queue int front,rear; int queue[size]; int i,j; void show(); void insert(int); void delete(); void main() { int j,i,ch,v; front=-1; rear=-1; do {

printf("Select the Menu operation\n"); printf("\n1.InsertQueue\n2.DeleteQueue\n3.Show\n4.Quit\n"); printf("Enter your choice\n"); scanf("%d",&ch); switch(ch) { case 1: printf("Enter the value\t"); scanf("%d",&v); insert(v); break; case 2: delete(); break; case 3: show(); break; } }while(ch<4); getch(); }

void show() // Display Queue items { if (front==rear) { printf("Empty queue"); return; } if(front <rear) { printf("Elements in the queue are\n"); for(i=front+1;i<=rear;i++) { printf("%d\n",queue[i]); } }

} void insert(int item) //Add item to Queue { if(rear==(size-1)) { printf("Queue overflow"); return; } rear++; queue[rear]=item; }

void delete() //Remove item from Queue { int v; if(front==rear) printf("Queue is empty"); else { front=front+1; v=queue[front]; printf("Element deleted from q is %d\n",v); } }

Output of the program

Select the Menu operation 1.InsertQueue 2.DeleteQueue 3.Show 4.Quit Enter your choice 1 Enter the value 22 Select the Menu operation

1.InsertQueue 2.DeleteQueue 3.Show 4.Quit Enter your choice 1 Enter the value 55 Select the Menu operation 1.InsertQueue 2.DeleteQueue 3.Show 4.Quit Enter your choice 3 Elements in the queue are 22 55 Select the Menu operation 1.InsertQueue 2.DeleteQueue 3.Show 4.Quit Enter your choice 2 Element deleted from q is 22 Select the Menu operation 1.InsertQueue 2.DeleteQueue 3.Show 4.Quit Enter your choice 3 Elements in the queue are 55 Select the Menu operation 1.InsertQueue 2.DeleteQueue 3.Show

4.Quit Enter your choice 4

Queue implementation using pointers Program 5.4

#include<stdio.h> struct queue { int v1; struct queue *link; }; struct queue * addqueue(struct queue *rear,int val); struct queue * deletequeue(struct queue *front ,int *val); void showqueue(struct queue *front);

void main() { struct queue *front,*rear; int val,ch; front=rear=NULL; do { printf("\n Menu for queue operation"); printf("\n 1.Add\n 2.Delete\n 3.Show\n 4.Exit"); printf("\nEnter u r choice\n"); scanf("%d",&ch); switch(ch) {

case 1: printf("Enter the value to be added\n"); scanf("%d",&val); rear=addqueue(rear,val); if(front==NULL) front=rear; break; case 2: front=deletequeue(front,&val); if(val!=-1) printf("The deleted value is %d",val); if(front==NULL) rear=front; break; case 3: showqueue(front); break; } }while(ch<4); getch(); } struct queue *addqueue(struct queue *rear,int val) //Add item to Queue { struct queue *w; w=(struct queue *)malloc (sizeof(struct queue)); w->v1=val; w->link=NULL; if(rear!=NULL) rear->link=w; rear=w; return(rear); } struct queue *deletequeue(struct queue *front ,int *val) //Remove item { struct queue *w; if(front==NULL) { printf("\n Sorry Queue is empty"); *val=-1;

} else { w=front; front=front->link; *val=w->v1; } return front; } void showqueue(struct queue *front) // Display Queue items { struct queue *p; p=front; printf("\nThe contents of queue is\n"); while(p!=NULL) { printf("%d",p->v1); p=p->link; } }

Output of the Program

Menu for queue operation 1.Add 2.Delete 3.Show 4.Exit Enter u r choice 1 Enter the value to be added 222

Menu for queue operation 1.Add 2.Delete

3.Show 4.Exit Enter u r choice 1 Enter the value to be added 555

Menu for queue operation 1.Add 2.Delete 3.Show 4.Exit Enter u r choice 3

The contents of queue is 222555 Menu for queue operation 1.Add 2.Delete 3.Show 4.Exit Enter u r choice 2 The deleted value is 222 Menu for queue operation 1.Add 2.Delete 3.Show 4.Exit Enter u r choice 3

The contents of queue is 555 Menu for queue operation

1.Add 2.Delete 3.Show 4.Exit Enter u r choice 4

5.5 Circular Queue In circular queue the elements are represented in a circular fashion like this cq[0],cq[1],cq[2], .cq[n-1].with cq[0] following cq[n-1]. In circular queue insertion of the element is done at the very first location of the queue if the last location of the queue is full.

Figure 5.3 Circular Queue implementation 5.5 Program

#include<stdio.h> #include<conio.h> void addcirqueue (int cq [],int*rear,int val,int *front); int deletecirqueue(int cq [],int *front,int *rear); void showcirqueue(int cq [],int *front,int *rear); int n;

void main() { int cq [35]; int ch,front,rear,val; printf("Enter the size of the circular queue\n"); scanf("%d",&n); front=rear=0; do { printf("\nMenu for circular queue operation"); printf("\n 1.Add\n 2.Delete\n 3.Show\n"); printf("\nEnter u r choice\n"); scanf("%d",&ch); switch(ch) { case 1: printf("Enter the value to be added\n"); scanf("%d",&val); addcirqueue(cq,&rear,val,&front); break; case 2: val=deletecirqueue(cq,&front,&rear); if(val!=0) printf("The deleted value is %d",val); break; case 3: showcirqueue(cq,&front,&rear); break; } }while(ch<4); getch(); } void addcirqueue (int cq[],int*rear,int val,int *front) { if((*rear+1)%n==*front) { printf("Queue is full");

} else { *rear=(*rear+1)%n; cq[*rear]=val; } } int deletecirqueue(int cq[],int *front,int *rear) { int v1; if(*front!=*rear) { *front=(*front+1)%n; v1=cq[*front]; return v1; } else { printf("Queue is empty"); return 0; } } void showcirqueue(int cq[],int *front,int *rear) { int j; j=*front; printf("Contents"); while(j!=*rear) { j=(j+1)%n; printf("\n%d",cq[j]); } }

Ouput of the program

Enter the size of the circular queue 5

Menu for circular queue operation 1.Add 2.Delete 3.Show

Enter u r choice 1 Enter the value to be added 222

Menu for circular queue operation 1.Add 2.Delete 3.Show

Enter u r choice 1 Enter the value to be added 444 Menu for circular queue operation 1.Add 2.Delete 3.Show Enter u r choice 3 Contents 222 444 Menu for circular queue operation 1.Add 2.Delete 3.Show

Enter u r choice 2 The deleted value is 222 Menu for circular queue operation 1.Add 2.Delete 3.Show

Enter u r choice 3 Contents 444 Menu for circular queue operation 1.Add 2.Delete 3.Show

Enter u r choice 4

5.6 Priority queue

Priority queue is another type of data structure in which each element is having a priority and elements having same priority form a separate queue. Thus a priority queue is equivalent to a queue of multiple queues, where elements having higher priority are processed before elements having lower priority.

Conceptual view of a priority queue

Figure 5.4

Implementation view

Figure 5.5

Program for priority Queue using linked list: 5.6 Program #include <stdio.h> struct node //The node with one data field one priority field and twp pointers { int data,priority; struct node *rightlink; struct node *leftlink; }; struct node *front,*rear,*list,*ptr,*new,*ptr1,*ptr2,*headptr,head,node1,node2; void insert(int item,int priority); // inserts a given item with a given

//priority to the queue int delete(int priority); /*checks whether an item with a given priority exists.If so it is removed */ void show();

void main() { int option,item1,priority; headptr=(struct node*)malloc(sizeof(struct node));//a pointer to head node head =*headptr; (*headptr).leftlink=NULL; (*headptr).rightlink=NULL; (*headptr).data=0; (*headptr).priority=-99; do { printf("\n 1)Add 2)Delete 3)Show 4)Exit\n"); scanf("%d",&option); switch(option) { case 1: printf("\nEnter the value to insert:\t"); scanf("%d",&item1); printf("\nenter the priority:\t"); scanf("%d",&priority); insert( item1, priority); break; case 2: printf("\nEnter the priority value to delete: "); scanf("%d",&priority); item1= delete( priority); break; case 3: show(); break;

} } while(option!=4); getch(); } void insert(int item ,int p) { ptr=headptr; new =(struct node*)malloc(sizeof(struct node)); (*new).data=item; (*new).priority=p; while(((*ptr).rightlink!=NULL)&&((*ptr).priority<p))/*scan through the list until we reach the end or an item with higher priority*/ { ptr=(*ptr).rightlink; }

if( (ptr==headptr) ||((*ptr).rightlink==NULL)&&((*ptr).priority<p)) /*end of the list. insert the item at the last */ { (*ptr).rightlink=new; //printf("data %d,priority %d",(*ptr).data,(*ptr).priority); (*new).leftlink=ptr; (*new).rightlink=NULL; rear=new; } else //insert the item before the item with higher priority if((*ptr).priority>=p) { ptr1=(*ptr).leftlink; (*ptr1).rightlink=new; (*new).rightlink=ptr; (*ptr).leftlink=new;

(*new).leftlink=ptr1; } front=headptr; } int delete(int p) { if(rear==NULL) { printf("\n queue is empty\n"); return(1); } else { ptr=rear; while( ((*ptr).priority>p)&&(ptr!=headptr)) { ptr=(*ptr).leftlink; } if((ptr==headptr)||(*ptr).priority<p) { printf("no item with that priority"); return(1); } else if((*ptr).priority==p) { ptr1=(*ptr).leftlink; ptr2=(*ptr).rightlink; if(ptr==rear) { rear=ptr1; (*ptr1).rightlink=NULL; } else { (*ptr1).rightlink=ptr2; (*ptr2).leftlink=ptr1;

} } } return((*ptr).data); }

void show() { if((*headptr).rightlink==NULL) { printf("the queue is empty"); return; } ptr1= (*headptr).rightlink; while(ptr1!=NULL) { printf("DATA: %d Priority %d\n",(*ptr1).data,(*ptr1).priority ); ptr1=(*ptr1).rightlink; }; }

Output of the Program 1)Add 2)Delete 3)Show 4)Exit 1 Enter the value to insert: 333 enter the priority: 2 1)Add 2)Delete 3)Show 4)Exit 1 Enter the value to insert: 777 enter the priority: 1 1)Add 2)Delete 3)Show 4)Exit 3 DATA: 777 Priority 1 DATA: 333 Priority 2 1)Add 2)Delete 3)Show 4)Exit

2 Enter the priority value to delete: 1 1)Add 2)Delete 3)Show 4)Exit 3 DATA: 333 Priority 2 1)Add 2)Delete 3)Show 4)Exit 4 5.7 Dequeue

Another data structure similar to queue, but operation such as insertion and deletion is made to or from both end of the queue. But insertion and deletion is not possible at the middle of the queue. There are two types of dequeue 1. Input restricted dequeue 2. Output restricted dequeue 5.8. Input Restricted Dequeue

This allows insertion only at one end of the array or list, but deletion allowed at both ends. 5.9 Output Restricted Dequeue This allows insertion at both ends of the list but deletion allowed at only one end of the array.

DEQUEUE Figure 5.5 Sample program for Dequeue 5.7 Program

#include<stdio.h> #define maxsize 30 int left,right; int dequeue[maxsize]; int i,j; void insertright(int item) // insert element to the right { if( ( (left==0)&&(right==(maxsize-1)))) { printf("queue is full"); return; } else if( left==-1)//empty queue { left++; right++; } else if(right==maxsize-1) right=0; else right++; dequeue[right]= item; } void show() // Displays the dequeue { int front=left; int rear =right; if (left== -1) { printf("empty queue"); return; } if(left <right) for(i=front;i<=rear;i++) printf("%d ",dequeue[i]); else { for(i=front;i <=maxsize-1;i++)

printf("%d ",dequeue[i]); for(i=0;i<=right;i++) printf("%d ",dequeue[i]); } printf("\n"); } void insertleft(int item) // Insert element to the left { if((left==0&&right==(maxsize-1))||(left==right+1)) { printf("\nq overflow"); return; } if(left==-1) { left++; right++; } else { if(left==0) left=maxsize-1; else left=left-1; dequeue[left]=item; } } void deleteleft() // Delete element from left { if(left==-1) { printf("\nqueue underflow"); return; } printf("element deleted from q is%d\n",dequeue[left]); if(left==right) { left=-1;

right=-1; } else if(left==maxsize-1) left=0; else left=left+1; } void deleteright() //Delete element from right { if(left==-1) { printf("queue underflow"); return; } printf("element deleted from q is%d\n ",dequeue[right]); if(left==right) { left=-1; right=-1; } else if(right==0) right=maxsize-1; else right=right-1; } void main() { int j,i,ch,v; left=-1; right=-1; do { printf("Select the Menu operation\n"); printf("\n1.InsertRight\n2.InsertLeft\n3.DeleteRight\n"); printf("4.DeleteLeft\n5.Show\n6.Quit\n"); printf("\nEnter your choice\n");

scanf("%d",&ch); switch(ch) { case 1: printf("Enter the value "); scanf("%d",&v); insertright(v); break; case 2: printf("Enter the value "); scanf("%d",&v); insertleft(v); break; case 3: deleteright(); break; case 4: deleteleft(); break; case 5: show(); break; } }while(ch<6); getch(); }

Output of the Program Select the Menu operation 1.InsertRight 2.InsertLeft 3.DeleteRight 4.DeleteLeft 5.Show 6.Quit Enter your choice

1 Enter the value 222 Select the Menu operation 1.InsertRight 2.InsertLeft 3.DeleteRight 4.DeleteLeft 5.Show 6.Quit Enter your choice 2 Enter the value 888 Select the Menu operation 1.InsertRight 2.InsertLeft 3.DeleteRight 4.DeleteLeft 5.Show 6.Quit Enter your choice 5 888 222 Select the Menu operation 1.InsertRight 2.InsertLeft 3.DeleteRight 4.DeleteLeft 5.Show 6.Quit

Enter your choice 3 element deleted from q is222 Select the Menu operation 1.InsertRight 2.InsertLeft

3.DeleteRight 4.DeleteLeft 5.Show 6.Quit Enter your choice 4 element deleted from q is888 Select the Menu operation 1.InsertRight 2.InsertLeft 3.DeleteRight 4.DeleteLeft 5.Show 6.Quit Enter your choice 5 empty queueSelect the Menu operation 1.InsertRight 2.InsertLeft 3.DeleteRight 4.DeleteLeft 5.Show 6.Quit Enter your choice 6

5.10 Applications of Queues

7. We can use queues in Time sharing systems. 8. We can use queues in computer networks. 9. Queues are used in simulation. 10. In computer systems communication between two process or two programs or two systems is done by sending messages. For this there must be a holding area for messages between two processes, two programs, or even two systems. This holding area is usually called a buffer and is often implemented as a queue. 11. Operating systems often maintain a queue of processes that are ready to execute or that are

waiting for a particular event to occur.

Exercises

11.2. Define stack 11.3. Explain push and pop operations in the stack 11.4. Write a c Program to implement a stack using an array 11.5. List out the applications of Stack 11.6. Define Queue 11.7. List Applications of queues 11.8. Write a C program to implement queue using Array 11.9. Implement a circular queue 11.10. What is a priority queue? 11.11. What are dequeues? 11.12. Implement a dequeue

Chapter Vl Linked List


6.1 Linked list

A linked list is a data structure. Linked list is a linear list of nodes, each containing data area and one or two pointers (links) pointing to the next coming or previous nodes. Advantage of linked list over array is that we do not need to mention the size of the elements in linked list application Using linked list we can insert and delete nodes from any point in the list. But linked list never allow doing random access of nodes. Several different types of linked list exist: singly-linked lists, doubly-linked lists, circularly-linked list and circular doubly linked lists. The following fig is an example for single Linked list.

Figure 6.1 linked list

6.2Creation of Linked List

We can insert and delete items in a linked list when it is necessary. The nodes of a linked list are written as structures. We use some memory location to store the nodes (structure variable).This location is accessed by means of pointers. The struct declaration does not allocate storage, but it describes the format of the nodes. Storage space of a node is created by the dynamic memory allocation function malloc. Here Pnode points to the structure variable node. Initially pointer points to the first node. Creation of linked list contains the following steps.

11. First we check that pnode1==NULL, if so we dynamically allocate memory for the pnode1 (first node).make pnodes link as NULL. Assign pnode as the first node. 12. If pnode1! =NULL, then we are allocating memory for the next node (pnode1 link). 6.3 Inserting Node Insertion of nodes in a linked list mainly carried out by three ways. 12. Insertion at first position: This is done by adding a new node and set its pointer to the current start. Start will be set to point to the list. 2. Insertion at the end section: This is done by adding a new node at the end point of the list. 3. Insertion in specified position: We need to mention the position of insertion. For that we are searching the entire list and insert the node at the right position.

Figure 6.2 Inserting a node 6.4 Deletion of nodes

We are deleting a node from the linked list by mentioning its data .And we are searching the entire linked list for the data, until we get it. Then we use free function to delete the node.

123 333 444

123

333 444

Figure 6.3 Deleting a node Program for linked list operations Program 6.1

#include<stdio.h> struct node1 { int value; struct node1 *link; }; struct node1 *pnode1,*first,*x,*t,*w;

void main() { int ch; void addList(); void deleteList(); void displayList(); pnode1=NULL; while(ch!=4) { printf("\nLinked list operation menu"); printf("\n1.Add\n2.Delete\n3.Display\n4.Exit\n"); printf("Enter u r choice\t"); scanf("%d",&ch); switch(ch) {

case 1: addList(); break; case 2: deleteList(); break; case 3: displayList(); break; } } getch(); }

void addList() //Add elements to list { int v; printf("Enter the value of the element\t"); scanf("%d",&v); if (pnode1==NULL) { pnode1=malloc(sizeof(struct node1)); pnode1->value=v; pnode1->link=NULL; first=pnode1; } else { pnode1->link=(struct node1*) malloc(sizeof(struct node1)); pnode1->link->value=v; pnode1=pnode1->link; } pnode1->link=NULL; }

void displayList() //Display elements in the List { printf("\n\n"); pnode1=first; while(pnode1!=NULL) { printf("%d->",pnode1->value); pnode1=pnode1->link; } printf("NULL"); }

void deleteList() //Display list elements { int v; printf("enter the value to delete"); scanf("%d",&v); pnode1=first; t=NULL; while(pnode1!=NULL&&pnode1->value!=v) { t=pnode1; pnode1=pnode1->link; } if(pnode1!=NULL) { if(t==NULL) first=first->link; else t->link=pnode1->link; free(pnode1); printf("Node Deleted"); } else { printf("Node with the given value not exit");

} } Output of the Program

Linked list operation menu 1.Add 2.Delete 3.Display 4.Exit Enter u r choice 1 Enter the value of the element 222

Linked list operation menu 1.Add 2.Delete 3.Display 4.Exit Enter u r choice 1 Enter the value of the element 111

Linked list operation menu 1.Add 2.Delete 3.Display 4.Exit Enter u r choice 3

222->111->NULL Linked list operation menu 1.Add 2.Delete 3.Display 4.Exit

Enter u r choice 2 enter the value to delete111 Node Deleted Linked list operation menu 1.Add 2.Delete 3.Display 4.Exit Enter u r choice 3

222->NULL Linked list operation menu 1.Add 2.Delete 3.Display 4.Exit Enter u r choice 4

6.5 Doubly-linked List Another type of linked list is a doubly-linked list or two-way linked list. Each node has two links: one points to the previous node, or points to a null value and one points to the next, or points to a null value .Here a node is divided into three parts, where three fields of information are stored. Leftlink: Holds the address of previous node. Data field: Holds the data item. Right link: Holds the address of the next node. The following figure for doubly linked list.

Figure 6.4 Doubly linked list

6.6 Operations on a doubly linked list

Using a doubly Linked List we can traverse both sides. Main operations of doubly Linked list are listed below. 3. creation 2. Insertion 3. Deletion 4. Traversal Here pnode1 (first node) has two links that are rlink and llink. Initially creating the first node in doubly linked list we are setting the first and last pointers points to that node. Again we are creating an another node, then last pointer points to the newly created node (t).Insertion and deletion operations are similar to the linear linked list. A Sample program for Doubly Linked List Program 6.2 #include<stdio.h> struct dlinklist { int no; struct dlinklist *rlink,*llink; }; struct dlinklist *pnode1,*first,*t,*last,*temp; void main() { void adddlist(); void viewdlist(); void insertNode(); void deleteNode(); int ch; pnode1=NULL; do { printf("\n Doubly Linked list operation menu"); printf("\n1.Add\n2.View\n3.InsertNode\n4.DeleteNode\n5.Exit\n"); printf("Enter u r choice\n");

scanf("%d",&ch); switch(ch) { case 1: adddlist(); break; case 2: viewdlist(); break; case 3: insertNode(); break; case 4: deleteNode(); break; } }while(ch<5); getch(); } void adddlist() //Add Elements to doubly linked list { if (pnode1==NULL) { pnode1=(struct dlinklist*)malloc(sizeof(struct dlinklist)); printf("\nEnter the value of the element "); scanf("%d",&pnode1->no); pnode1->llink=NULL; pnode1->rlink=NULL; first=pnode1; last=pnode1; } else { t=(struct dlinklist*) malloc(sizeof(struct dlinklist)); printf("\nEnter the value of the element "); scanf("%d",&t->no); t->rlink=NULL; t->llink=pnode1;

pnode1->rlink=t; pnode1=pnode1->rlink; last=t; } } void viewdlist() // Display Elements of the list { printf("Enter the element from left to right\n"); temp=first; printf("NULL->"); while(temp!=NULL) { printf("%d->",temp->no); temp=temp->rlink; } printf("NULL\n"); printf("Enter the element from l right to left\n"); temp=last; printf("NULL->"); while(temp!=NULL) { printf("%d->",temp->no); temp=temp->llink; } printf("NULL"); } void insertNode() // Insert an element after another element { int val; struct dlinklist *newnode; printf("Enter after the value:"); scanf("%d",&val); temp=first; while(temp->no!=val) { temp=temp->rlink; if(temp==NULL)

{ printf("Value not found"); return; } } if(temp->no==val) { newnode=(struct dlinklist*) malloc(sizeof(struct dlinklist)); printf("\n Enter the value to insert "); scanf("%d",&newnode->no); newnode->rlink=temp->rlink; temp->rlink=newnode; newnode->llink=temp; newnode->rlink->llink=newnode; } } void deleteNode() //Delete element from the list { int val; printf("Enter the value to delete "); scanf("%d",&val); if(first->no==val) { first=first->rlink; first->llink=NULL; } else { temp=first; while(temp!=NULL&&temp->rlink->no!=val) temp=temp->rlink; if(temp==NULL) { printf("value not found in the list"); } temp->rlink=temp->rlink->rlink; temp->rlink->llink=temp; }

Output of the Program Doubly Linked list operation menu 1.Add 2.View 3.InsertNode 4.DeleteNode 5.Exit Enter u r choice 1 Enter the value of the element 333 Doubly Linked list operation menu 1.Add 2.View 3.InsertNode 4.DeleteNode 5.Exit Enter u r choice 1 Enter the value of the element 555 Doubly Linked list operation menu 1.Add 2.View 3.InsertNode 4.DeleteNode 5.Exit Enter u r choice 2 Enter the element from left to right NULL->333->555->NULL Enter the element from l right to left NULL->555->333->NULL Doubly Linked list operation menu 1.Add

2.View 3.InsertNode 4.DeleteNode 5.Exit Enter u r choice 3 Enter after the value:333 Enter the value to insert 444 Doubly Linked list operation menu 1.Add 2.View 3.InsertNode 4.DeleteNode 5.Exit Enter u r choice 2 Enter the element from left to right NULL->333->444->555->NULL Enter the element from l right to left NULL->555->444->333->NULL Doubly Linked list operation menu 1.Add 2.View 3.InsertNode 4.DeleteNode 5.Exit Enter u r choice 4 Enter the value to delete 444 Doubly Linked list operation menu 1.Add 2.View 3.InsertNode 4.DeleteNode 5.Exit Enter u r choice 2 Enter the element from left to right

NULL->333->555->NULL Enter the element from l right to left NULL->555->333->NULL Doubly Linked list operation menu 1.Add 2.View 3.InsertNode 4.DeleteNode 5.Exit Enter u r choice 5

6.7 Circular Linked List

Circular linked list is similar to singly linked list. In the last node of the circular linked list we are storing the address of the first node. So we can directly go to the first node from last node

Advantage: Back traversal is possible in circular linked list. Disadvantage: In circular linked list there is a probability for an infinite loop.

Figure 6.5 circular linked list

Program for Circular Linked List:

Program 6.3 #include <stdio.h> #include <malloc.h> struct circularlink { int info; struct circularlink *next; }; struct circularlink *lastnode; void makeList(int); void deleteNode(int); void showList(); void insertFirst(int); void insertAfter(int,int); void main() { int option; int n,value,position,i; lastnode=NULL; do { printf("1.MakeList\n"); printf("2.Insert First\n"); printf("3.Insert After \n"); printf("4.Delete\n"); printf("5.ShowList\n"); printf("6.Quit\n"); printf("Enter your choice : "); scanf("%d",&option); switch(option) { case 1: printf("Enter the number of nodes "); scanf("%d",&n); for(i=0; i < n;i++) {

scanf("%d",&value); makeList(value); } break; case 2: printf("Enter the element : "); scanf("%d",&value); insertFirst(value); break; case 3: printf("Enter the element : "); scanf("%d",&value); printf("Enter the position after which this element is inserted : "); scanf("%d",&position); insertAfter(value,position); break; case 4: if(lastnode == NULL) { printf("List underflow\n"); continue; } printf("Enter the number for deletion : "); scanf("%d",&value); deleteNode(value); break; case 5: showList(); break;

}/*End of switch*/ }while(option<6);/*End of while*/ getch(); }/*End of main()*/ void makeList(int num) // Creating a list {

struct circularlink *q,*tmp; tmp= malloc(sizeof(struct circularlink)); tmp->info = num; if(lastnode == NULL) { lastnode = tmp; tmp->next = lastnode; } else { tmp->next = lastnode->next; /*added at the end of list*/ lastnode->next = tmp; lastnode = tmp; } }/*End of makeList()*/ void insertFirst(int num) // Insert element at first position { struct circularlink *tmp; tmp = malloc(sizeof(struct circularlink)); tmp->info = num; tmp->next = lastnode->next; lastnode->next = tmp; }/*End of insertFirst()*/ void insertAfter(int num,int pos) // Insert element after a position { struct circularlink *tmp,*q; int i; q = lastnode->next; for(i=0; i < pos-1; i++) { q = q->next; if(q == lastnode->next) { printf("There are less than %d elements\n",pos);

return; } }/*End of for*/ tmp = malloc(sizeof(struct circularlink) ); tmp->next = q->next; tmp->info = num; q->next = tmp; if(q==lastnode) /*Element inserted at the end*/ lastnode=tmp; }/*End of insertAfter()*/ void deleteNode(int num) //Delete a particular node { struct circularlink *tmp,*q; if( lastnode->next == lastnode && lastnode->info == num) /*Only one element*/ { tmp = lastnode; lastnode = NULL; free(tmp); return; } q = lastnode->next; if(q->info == num) { tmp = q; lastnode->next = q->next; free(tmp); return; } while(q->next != lastnode) { if(q->next->info == num) { tmp = q->next; q->next = tmp->next; free(tmp); printf("%d deleted\n",num); return;

} q = q->next; }/*End of while*/ if(q->next->info == num) { tmp = q->next; q->next = lastnode->next; free(tmp); lastnode = q; return; } printf("Element %d not found\n",num); }/*End of deleteNode()*/ void showList() // Display elements { struct circularlink *q; if(lastnode == NULL) { printf("List is empty\n"); return; } q = lastnode->next; printf("List is :\n"); while(q != lastnode) { printf("%d ", q->info); q = q->next; } printf("%d\n",lastnode->info); }/*End of showList()*/

Output of the Program 1.MakeList 2.Insert First 3.Insert After 4.Delete

5.Show List 6.Quit Enter your choice : 1 Enter the number of nodes 4 11 33 44 55 1.MakeList 2.Insert First 3.Insert After 4.Delete 5.Show List 6.Quit Enter your choice : 3 Enter the element : 22 Enter the position after which this element is inserted : 1 1.MakeList 2. Insert First 3.Insert After 4.Delete 5.Show List 6.Quit Enter your choice : 5 List is : 11 22 33 44 55 1.MakeList 2.Insert First 3.Insert After 4.Delete 5. Show List 6.Quit Enter your choice : 4 Enter the number for deletion : 22 22 deleted 1.MakeList 2.Insert First 3.Insert After 4.Delete 5.Show List 6.Quit

Enter your choice : 5 List is : 11 33 44 55 1.MakeList 2.Insert First 3.Insert After 4.Delete 5.Show List 6.Quit Enter your choice : 6

6.8 Circular Doubly-linked List Circular doubly linked list is a doubly linked list in which the last node of the list has its next pointer pointing to the first node, and the previous pointer of the first node points to the last node. In a circular doubly linked list we can be traverse clockwise or anticlockwise manner. In this list all nodes are linked as shown in the below figure. The only difference between double linked list and circular double linked list is that here last node points to first node and first node points to last node .But in doubly linked list last node points to the NULL value.

Figure (6.5) circular doubly linked list A Sample program for Circular doubly linked list 6.4 Program #include<stdio.h> #include<conio.h> struct cirdl {

int v; struct cirdl *r,*l; }; void addcirdl(); void printltor(); void printrtol(); void deletecird1(); struct cirdl *head,*pnode1,*t; int ch; void main() { head=(struct cirdl*)malloc(sizeof(struct cirdl)); head->r=head; head->l=head; pnode1=head; do { printf("\nCircular Doubly Linked list operation menu\n"); printf("1.Add\n2.PrintFromleft\n3.PrintFromRight\n4.Delete\n5.Exit"); printf("\nEnter u r choice\t"); scanf("%d",&ch); switch(ch) { case 1: addcirdl(); break; case 2: printltor (); break; case 3: printrtol(); break; case 4: deletecird1(); break;

} }while(ch<5); getch(); }

void addcirdl() // Add Elements to list { if(pnode1==head) { pnode1=(struct cirdl*)malloc(sizeof(struct cirdl)); printf("\nEnter the value to insert\t"); scanf("%d",&pnode1->v); pnode1->l=head; pnode1->r=head; head->r=pnode1; head->l=pnode1; } else { t =(struct cirdl*)malloc(sizeof(struct cirdl)); printf("\nEnter the value to insert\t"); scanf("%d",&t->v); t->l=pnode1; pnode1->r=t; t->r=head; head->l=t; pnode1=pnode1->r; } }

void printltor() // Print elements from left to right { pnode1=head->r; while(pnode1!=head->l) { printf("%d->",pnode1->v); pnode1=pnode1->r;

} printf("%d",pnode1->v);

void deletecird1() // Delete a particular element { int v; printf("Enter the value to delete\t"); scanf("%d",&v); pnode1=head->r; if(v==pnode1->v) { head->r=pnode1->r; pnode1->r=head; } else { while(v!=pnode1->r->v&&pnode1!=head->l) pnode1=pnode1->r; pnode1->r=pnode1->r->r; pnode1->r->l=pnode1; } if(pnode1==head->l) { printf(" Sorry no such nodes exits"); } }

void printrtol() // Print Elements from eight to left { pnode1=head->l; while(pnode1!=head->r) { printf("%d->",pnode1->v);

pnode1=pnode1->l; } printf("%d",pnode1->v); }

Output of the Program

Circular Doubly Linked list operation menu 1.Add 2.PrintFromleft 3.PrintFromRight 4.Delete 5.Exit Enter u r choice 1 Enter the value to insert 12 Circular Doubly Linked list operation menu 1.Add 2.PrintFromleft 3.PrintFromRight 4.Delete 5.Exit Enter u r choice 1 Enter the value to insert 14 Circular Doubly Linked list operation menu 1.Add 2.PrintFromleft 3.PrintFromRight 4.Delete 5.Exit Enter u r choice 1 Enter the value to insert 16 Circular Doubly Linked list operation menu 1.Add 2.PrintFromleft 3.PrintFromRight 4.Delete

5.Exit Enter u r choice 2 12->14->16 Circular Doubly Linked list operation menu 1.Add 2.PrintFromleft 3.PrintFromRight 4.Delete 5.Exit Enter u r choice 3 16->14->12 Circular Doubly Linked list operation menu 1.Add 2.PrintFromleft 3.PrintFromRight 4.Delete 5.Exit Enter u r choice 4 Enter the value to delete 14 Circular Doubly Linked list operation menu 1.Add 2.PrintFromleft 3.PrintFromRight 4.Delete 5.Exit Enter u r choice 2 12->16 Circular Doubly Linked list operation menu 1.Add 2.PrintFromleft 3.PrintFromRight 4.Delete 5.Exit Enter u r choice 5

6.9Advantages/Disadvantages of Linked Lists

Advantage

4. Linked lists use dynamic memory allocation. This makes efficient use of main memory. 5. Insertion and deletion of nodes arbitrary positions is easy. For insertion and deletion we need to just adjust the pointers. 6. We can move both directions using doubly linked list. 7. Linked lists do not require continuous memory blocks for allocation. 8. Linked list can grow and shrink according to user requiements

Disadvantage:

8. We have to mention the proper termination otherwise there is a probability for an infinite loop. 9. Doubly linked list take additional space to hold the address of the next node and address of the previous node. 10. Linked list allows only sequential access to elements access time is greater.

EXERCISE

1. What is a linked list? 2. Define circular linked list. List out its advantage and disadvantages. 3. Define doubly linked list. 4. List out the advantages and disadvantages of Linked list. 5. Write a program to search a particular value in a singly linked list. 6. List out the different steps for the creation of linked list. 7. Write a C program to implement doubly linked list. 8. Explain circular linked list. 9. Write a C program to implement Circular linked list. 10. Explain circular doubly linked list. 11. Write a C program to implement Circular doubly linked list. 12. Write a C program to reverse the linked list.

Chapter Vll TREES


7.1 Tree :

A tree is a finite set of nodes such that there is a special node called the ROOT and remaining nodes are divided in to disjoined sets, where each of the set is a tree.

Figure 7.1 Tree

7.2 ROOT:

Root is a special node .It is the first node or top node in the tree. Every tree has only one root. In the above figure (7.1) T is the root node.

7.3 Degree:

Degree of a node is the number of sub trees of the node, example, t1.t2, t3.Trees with 0 degree is known as leaf nodes or terminal nodes.

Root of the sub tree of a node is called children of the node. If X is a node, Y is a child of X then X is called the parent of Y.Nodes having the same parents are called as Siblings. The maximum degree of nodes of a tree is called the degree of the tree. A path among two nodes X and Y of a tree is list of nodes starting from X and ending in Y with no node repeating.

7.4 Pathlengh

The number edges on a path are called the length of the path. it is one less than the number of nodes in the path.

7.5 Level

The level of the node is defined as follows: The level of the root is 1, and then the level of the child is 1+ level of the parent. 7.6 Forest

A set of trees which are disjoint (Having no common nodes) is called as forest. For example: If we take the tree in the above example and delete the root node, we get a forest consisting of three disjoint trees.

Forest

A E F

B C D F G H

Figure 7.2 Forest

7.7 Labeled trees If a label (name) is assigned to each node of a tree, then it is called a labeled tree. A

B C D

F E

G H

Figure 7.3 Labeled tree

7.8 Binary tree A binary tree can be defined as tree in which every node has degree at most two. That is a tree is a binary tree if every node has Zero, One or Two children. The two sub trees of a binary tree are called left sub tree and right sub tree.

Figure 7.4 Binary Tree

7.9 Application of trees

Trees have a variety of application. Some of them have listed below.

Decision trees : when taking a decision we will have to consider several alternative and the decision is based on various condition this can be formulated as a tree If it rains or if it hot I will stay onside, else I will go out.

Figure 7.5 Decision Tree Game trees: many games like tick tack toe, chess, drought, etc can be modeled by trees. Here the board positions are represented by nodes and edges represent moves. The root is the start position and finding a good move requires searching the tree. Representing sets: In a set element can be represented by nodes and disjoint sub sets can be represented by sub trees. This representation makes operation like union very convenient.

Oct trees and quad trees are used in computer graphics where a picture or a solid object is divided in to different parts, and each part is further divided, forming a tree representation of the picture or object. This representation saves much space and also is convenient for manipulating picture and objects. 7.10 Binary tree operations The common operations on a binary tree are: 10. Inserting a node

First we create a new node with the item as value. Then we search the binary tree to find a node to which the given item can be inserted as the child node. We get a new binary tree with the given node inserted. 2. Deleting a node In deletion there are three cases 2. The node to be deleted is a leaf node. In this case in the parent of the node, the pointer to the node is made Null and the node is freed. 2. The node to be deleted has only one child. In this case in the parent of the node, the pointer to the node is replaced by a pointer to the only child and the node is freed. 3. The node has both a left child and a right child. In this case the inorder successor of the node is deleted after storing its value in a temporary variable. Then the value of the node is changed to the stored value. Consider a tree having sub trees on both sides; here we are going to delete the node 25, for that we need to find out the inorder successor of the node 25.We get the Inorder successor by traversing the tree in inorder. Tree visited in sequence 20, 25,30,40,45,120,125,140,150. From sequence we found that 30 come after 25. After deletion tree looks like fig(7.5).

Figure (7.6) Figure (7.7)

3. Searching for a node.

It is examined whether a given node is in the tree or not.

Sample Program for implementing tree operations Program 7.1 #include<stdio.h> #include<conio.h> #include<stdlib.h> struct BinaryTree { int n; struct BinaryTree *left; struct BinaryTree *right; }typedef BinaryTree; BinaryTree *root,*ptr,*prev,*bfor,*x,*y; int num; void main() { int ch; void createNewTree(); void displayTree(BinaryTree *); void searchTree(BinaryTree *); void insertTree(BinaryTree *); void deleteTree(BinaryTree *); do { printf("\n1.CREATENEW\n2.PRINT\n3.SEARCH\n4.INSERT\n5.DELETE\n6.EXIT"); printf("\nEnter your choice\t"); scanf("%d",&ch); switch(ch) { case 1 : { createNewTree(); break; } case 2 : { displayTree(root);

break; } case 3 : { searchTree(root); break; } case 4 : { insertTree(root); break; } case 5 : { deleteTree(root); break; } } }while(ch<6); getch(); } void createNewTree() // Creates a new binary tree { int n,i; BinaryTree *temp; root=NULL; printf("Enter the number of nodes\t"); scanf("%d",&n); for(i=0;i<n;i++) { printf("Enter the number "); scanf("%d",&num); if(root==NULL) { temp=(BinaryTree *)malloc(sizeof(BinaryTree )); temp->n=num; temp->left=temp->right=NULL; root=temp; } else { ptr=prev=root; do

{ if(num<ptr->n) { prev=ptr; ptr=ptr->left; } else if(num > ptr->n) { prev=ptr; ptr=ptr->right; } else { prev=NULL; break; } }while(ptr); if(prev) { temp=(BinaryTree*)malloc(sizeof(BinaryTree)); temp->n=num; temp->left=temp->right=NULL; if(temp->n<prev->n) prev->left=temp; if(temp->n > prev->n) prev->right=temp; } else printf("'%d' is already present..",num); } } } void displayTree(BinaryTree *ptr) // Displays the elements of the tree { if(!ptr) { printf("Tree empty..."); return; } void preorder(BinaryTree *ptr); printf("Root is '%d'",root->n); printf("\n Elements are .... "); preorder(root); }

void preorder(BinaryTree *ptr) { if(!ptr) return; printf("%2d ",ptr->n); preorder(ptr->left); preorder(ptr->right); return; }

void searchTree(BinaryTree *ptr) // Searches a particular element { if(!ptr) { if(ptr == root) { printf("Empty Tree"); return; } } printf("Enter the number to search : "); scanf("%d",&num); while(ptr) { if(ptr->n == num) { printf("Search Successfull..."); return; } else if(ptr->n<num) ptr=ptr->right; else ptr=ptr->left; } printf("Search UnSuccessfull..."); } void insertTree(BinaryTree *ptr) // Insert an element {

BinaryTree *temp; if(!ptr) { printf("Tree is empty...First create & then insert... "); return; } ptr=prev=root; printf("Enter number to be inserted : "); scanf("%d",&num); do { if(num<ptr->n) { prev=ptr; ptr=ptr->left; } else if(num > ptr->n) { prev=ptr; ptr=ptr->right; } else { prev=NULL; break; } }while(ptr); if(prev) { temp=(BinaryTree *)malloc(sizeof(BinaryTree )); temp->n=num; temp->left=temp->right=NULL; if(temp->n <prev->n) prev->left=temp; if(temp->n > prev->n) prev->right=temp; printf("'%d' is inserted...",num); } else printf("'%d' is already present...",num); return; }

void deleteTree(BinaryTree *ptr) // Deletes a particular element { if(!ptr) { if(ptr == root) { printf("Empty Tree"); return; } } printf("Enter the number to be deleted : "); scanf("%d",&num); prev=ptr; while(ptr) { if(ptr->n == num) { if(ptr==root) { x=ptr->right; root=x; while(x->left) x=x->left; x->left=ptr->left; free(ptr); printf("'%d' is deleted...",num); return; } else if(!(ptr->left) && !(ptr->right)) { if(prev->left == ptr) prev->left=NULL; else prev->right=NULL; free(ptr); printf("'%d' is deleted...",num); return; } else if(!(ptr->left)) { if(prev->left == ptr) { prev->left=ptr->right;

free(ptr); } else if(prev->right == ptr) { prev->right=ptr->right; free(ptr); } printf("'%d' is deleted...",num); return; } else if(!(ptr->right)) { if(prev->left == ptr) { prev->left=ptr->left; free(ptr); } else if(prev->right == ptr) { prev->right=ptr->left; free(ptr); } printf("'%d' is deleted...",num); return; } else { x=ptr->right; while(x->left) x=x->left; x->left=ptr->left; if(prev->left == ptr) prev->left=ptr->right; else if(prev->right == ptr) prev->right=ptr->right; free(ptr); printf("'%d' is deleted...",num); return; } } else if(ptr->n <num) { prev=ptr; ptr=ptr->right; }

else { prev=ptr; ptr=ptr->left; } } printf("No Such Element Found.."); }

Output of the Program 1.CREATENEW 2.PRINT 3.SEARCH 4.INSERT 5.DELETE 6.EXIT Enter your choice 1 Enter the number of nodes 3 Enter the number 50 Enter the number 40 Enter the number 60 1.CREATENEW 2.PRINT 3.SEARCH 4.INSERT 5.DELETE 6.EXIT Enter your choice 2 Root is '50' Elements are .... 50 40 60 1.CREATENEW 2.PRINT 3.SEARCH 4.INSERT 5.DELETE 6.EXIT Enter your choice 4 Enter number to be inserted : 70 '70' is inserted... 1.CREATENEW 2.PRINT 3.SEARCH

4.INSERT 5.DELETE 6.EXIT Enter your choice 2 Root is '50' Elements are .... 50 40 60 70 1.CREATENEW 2.PRINT 3.SEARCH 4.INSERT 5.DELETE 6.EXIT Enter your choice 3 Enter the number to search : 70 Search Successfull... 1.CREATENEW 2.PRINT 3.SEARCH 4.INSERT 5.DELETE 6.EXIT Enter your choice 5 Enter the number to be deleted : 60 '60' is deleted... 1.CREATENEW 2.PRINT 3.SEARCH 4.INSERT 5.DELETE 6.EXIT Enter your choice 2 Root is '50' Elements are .... 50 40 70 1.CREATENEW 2.PRINT 3.SEARCH 4.INSERT 5.DELETE 6.EXIT Enter your choice 6

7.11 Tree traversal methods

By traversing a tree, we mean visiting the nodes of the tree in a systematic fashion. Based on the order in which we visit the nodes of a tree there are three tree traversal methods. The methods and the algorithm are given below: 3. Inorder traversal Traverse the left subtree in Inorder, visit the root and traverse the right sub tree in Inorder. 2. Pre order traversal Visit the root node, traverse the left sub tree in pre order, and traverse the right sub tree in pre order. 3. Post order traversal Traverse the left sub tree in post order, traverse the right sub tree in post order, and visit the root. We can explain the tree traversal with the following example.

Figure 7.8

Inorder traversal 20, 25, 30, 40, 45, 120, 125, 140,150 Pre-order traversal 120, 45, 25, 20, 40, 30, 140, 125, 150 Post-order traversal 20, 30, 40, 25, 45, 125, 150, 140, 120

Sample program for tree traversal Program 7.1 #include<stdio.h>

struct treenode1 { struct treenode1 *left; char data; struct treenode1 *right;

}; typedef struct treenode1 tree; tree *root=NULL; void inserttree(); void inorder(tree*); void postorder(tree*); void preorder(tree*); int number,no; void main() { int i,option; printf("\n\tTree Operation-Menu\n"); printf("\n1.InsertNode\n2.Inorder\n3.Preorder\n4.Ppostorder\n5.Exit\n"); do { printf("\nEnter your operation\t"); scanf("%d",&option); switch(option) { case 1: inserttree(); break; case 2: printf("\nIn order traversal\n"); inorder(root); break; case 3: printf("\nPre order traversal\n"); preorder(root); break; case 4: printf("\nPost order traversal\n"); postorder(root); break; } }while(option<5); getch(); } void inserttree() // Insert nodes to tree { tree *t,*p,*q; printf("Enter a number\t"); scanf("%d",&number); q=(tree*)malloc(sizeof(tree)); q->data=number;

q->left=NULL; q->right=NULL; if(root==NULL) { root=q; return; } p=root; t=NULL; while(p!=NULL) { t=p; if(p->data>number) p=p->left; else p=p->right; } if(t->data>number) t->left=q; else t->right=q; } void inorder(tree *p) { if(p!=NULL) { inorder(p->left); printf("%d ",p->data); inorder(p->right); } } void preorder(tree *p) { if(p!=NULL) { printf("%d ",p->data); preorder(p->left); preorder(p->right); } } void postorder(tree *p) { if(p!=NULL) { postorder(p->left);

postorder(p->right); printf("%d ",p->data); } }

Output of the Program

Tree Operation-Menu 1.InsertNode 2.Inorder 3.Preorder 4.Ppostorder 5.Exit Enter your operation 1 Enter a number 50 Enter your operation 1 Enter a number 90 Enter your operation 1 Enter a number 80 Enter your operation 1 Enter a number 40 Enter your operation 1 Enter a number 30 Enter your operation 2 In order traversal 30 40 50 80 90 Enter your operation 3 Pre order traversal 50 40 30 90 80 Enter your operation 4 Post order traversal 30 40 80 90 50 Enter your operation 5

7.12 Binary Search tree

A binary search tree is a binary tree with the following properties. The value of every node is unique. The value of each node in the left sub tree is less than the value of any node in the right sub tree. The value of any node in the left sub tree is less than the value of the root. The value of any node in the right sub tree is greater than the value of the root. Sub trees also satisfy the above properties. 7.13 Threaded binary tree A threaded binary tree is a binary tree in which every node without a right child has a pointer to its successor in an Inorder traversal. These pointers are called threads.

Figure 7.9 Threaded binary tree

7.14 Use of threaded binary trees Threaded binary tree can be used in tree traversal. If we use a threaded binary tree we can avoid recursion and the use of stacks. This saves a lot of memory and is much faster than recursive methods.

Exercises
3. What is tree? 4. Define sub tree. 5. Define root node and leaf node. 6. Define degree and level of a tree. 7. Explain the terms forest and labeled tree. 8. Explain the Application of trees. 9. What is a binary tree? Discuss the binary tree operation. 10. Discuss the different tree traversal methods. 11. What is binary search tree? 12. What is threaded binary tree? 11. Write a C program to implement the binary tree operations. 12. Write a c program to implement tree traversal. 13. Discuss the use of threaded binary tree.

Chapter Vlll GRAPH


8.1 Graph

Graph is also a nonlinear data structure which has application in many areas like networking, geographical information systems, traffic plannings, project management and chemistry. 8.2 Definition

A graph G consists of a set of V of vertices and a set E of edges between the vertices. It can be represented as G= (V, E). Where V is a finate set of vertices and E is a set of pairs of vertices called edges.

Figure 8.1 Graph A graph can be either directed or undirected. In an undirected graph every edge is represented by unordered pair of vertices, whereas in a directed graph the edges are represented by ordered pairs of vertices. That is ,if u and v are vertices then in a directed graph an edge from u to v is represented as (u,v) and an edge from v to u is represented by (v,u).Also these are different edges. But in undirected graph (u,v) and (v,u) represent same edge between u and v.We use directed arrows to draw an edge in a directed graph and undirected line segments to draw edges in an undirected graph .see figures below

Figure 8.3 Figure 8.4

If( x, y) is an edge in a directed graph we say that xis adjacent to y. and y is adjacent from x.In the case of a undirected graph if (x,y ) is an edge, we say that x and y are adjacent. In the above example in figure (8.3), vertex a is adjacent to vertex c and vertex c is adjacent from a. In figure (8.4) vertices a and c are adjacent to each other. A subgraph of a graph G=(V,E) is a graph G =(V,E) such that the vertex set V of G is a subset of the vertex set V of G,and the set of edges Eof G is a subset of the set of edges E of G. A path from a vertex x to a vertex y in a graph G is a sequence of vertices. x =v0 ,v1,,vr=y such that all vertices except possibly the first and last are distinct and (v0,v1), (v1,v2),,(vr-1,vr) are edges in G.The number of edges in a path is called Length of a path. A cycle is a path with first and last matrix is same. An undirected graph is said to be connected if there is a path between every two distinct vertices. Other wise it called as disconnected. Representation of a Graph A graph can be represented in many ways, but the most used methods are given below: 1. Adjacency matrix representation 2. Adjacency list representation 8.3 Adjacency matrix representation Here a graph with n vertices {v1,v2,,vn} is represented by an nxn matrix A. This matrix is called the adjacency matrix of the graph. In this matrix, the i,j th entry A[i,j] is 1 if there is an edge from vertex i to vertex j. Otherwise it is 0.

Example:

Figure 8.5 Directed graph Figure 8.6 Adjacency Matrix

Figure 8.7 Figure 8.8

8.4 Adjacency list representation

In Adjacency list representation a linked list consisting of vertices adjacent to given vertex is attached to the vertex.

Figure 8.9 Figure 8.10 8.5 DFS and BFS

Given an undirected graph G and a vertex x, we may want to visit all vertices in G which are reachable from x in a systematic fashion. There are many methods to do this. Two of the most popular methods are listed below: 13. Depth First Search (DFS). 14. Breadth First Search (BFS). 8.6 Depth First Search (DFS).

In DFS we are going to visit the vertices in depth wise fashion. Starting from a vertex we are going to visit one of its neighbors, and then one of its neighbors and so on until the current vertex has no unvisited neighbors. Then we backtrack and continue visiting the next neighbor of the earlier vertex. Figure (8.13) shows the DFS spanning tree for the tree given in figure (8.11).

8.7 Breadth First Search (BFS)

In breadth first search we visit the vertices in a breadth wise fashion. Here first of all we start from a vertex, then visit all its neighbors, and then visit the neighbors of the neighbors and so on. Queue data

structure is used here. Figure (8.12) shows the BFS spanning tree for the tree given in figure (8.11).

Figure 8.11 Figure 8.12

Figure 8.13

In the figures above an undirected graph is visited starting from vertex 1. The DFS and BFS generate trees called the DFS tree and BFS tree respectively. These trees contain all the vertices of the graph G and are spanning trees.

BFS algorithm Input : A graph G and a source vertex s of G Output: A BFS Tree of the graph 14. Create a queue Q 15. Add s to Q 16. mark s 17. make s as the root of the tree T

5. while Q is not empty: 6. Remove a vertex v from Q 7. for each edge (v ,w) of G 8. if w is not marked: 9. mark w, 10. Make v the parent of w in T 11. add w to Q 12. end if 13. end while 14. Return T 15. STOP

Time complexity of BFS Since in the worst case BFS will have to consider all edges, the time complexity is O(m+n) on a graph with n vertices and m edges. Space complexity of BFS

Applications of BFS Breadth first search has many applications. Some of them are given below.
1 .Identifying connected components of a graph. BFS can be used to find all connected components in a graph. By starting from an arbitrary vertex BFS ends when all the vertices which are connected to that vertex is explored. Then start ing from a remaining vertex we get the next connected component.In this way we can find all the connected components. 2.Checking weather a graph is bipartite or not

A bipartite graph has the property that it has no cycles with an odd number of vertices. A bipartite graph can be recognosed by BFS.

3.Finding the shortest path from one vertex to all other vertices. A BFS starting from a single vertex gives a tree in which the path from the root to any other vertex is a shortest path.

DFS algorithm BFS algorithm Input : A graph G and a source vertex s of G Output: A DFS Tree of the graph

15. Create a Stack R 16. Push s to R 17. mark s 18. make s as the root of the tree T

5. while R is not empty: 6. pop a vertex v from R 7. for each edge (v ,w) of G 8. if w is not marked: 9. mark w, 10. Make v the parent of w in T 11. push w to R 12. end if 13. end while 14. Return T 15. STOP Time complexity Since in the worst case DFS will have to consider all edges of the graph and all vertices, the time complexity is O(m+n) on a graph with n vertices and m edges.

Applications DFS have a wide variety of applications.Some of them are given below. 15. .Finding the connected components of a graph. 16. In game playing 17. Solving mazes 18. Checking weather a given graph is planar (Weather it can be drawn on the pane without edges crossing) 5.Topological sorting. Notice That The only difference between DFS and BFS is that we use a Stack in DFS instead of a queue in BFS.

8.8 Shortest path and Dijkstra Algorithm

A shortest path from a vertex x to y in a graph G is a path from x to y having minimum number of edges .The length of any shortest path from x to y is the distance from x to y, and is denoted by d(x,y)..In an undirected graph d(x, y) and d(y, x) are same.

8.9 Weighed graph

A directed graph in which weights are assigned on edges is called a weighted graph.

Figure 8.14 A weighed graph may be used to represent many real life problems. For example a weighed graph may represent a road net work. Here vertices may represent cities; edges may represent roads between the cities. Weights indicating the cost of moving from one city to another city. A shortest path from a vertex x to a vertex y is a path from x to y B such that the sum of the weights of the edges in the path is minimum.

8.10 Dijkstra Algorithm

Dijkstra algorithm is used to find the shortest path and the costs of the paths from a given vertex x to all other vertices in a weighed graph G. Here we assume that all the costs are non-negative. Dijkstras Algorithm works by keeping a set of vertices whose distance from x is already determined. The algorithm proceeds by selecting a vertex v not in S, whose distance from all vertices of S is minimum. The time complexity of the algorithm is O (n ), where n is the number of vertices. The following program implements the algorithm
2

Program 8.1 #include <stdio.h>

int distanceMatrix[20][20]; // To store the distance matrix int shortestPath[20]; // To store the shortest paths int findMax(int a, int b) // Find maximum of two numbers { if(a>b) return a; else return b; } void printPath(int sv,int n)// displays the shortest paths { int i; printf("From To ShortestPath\n\n"); for (i = 1; i <= n; ++i) { printf("%d %d %ld\n",sv,i,shortestPath[i]); } printf("\n"); }

void findPath(int sv,int n) //Find the shortest paths using Dijkstra's algorithm { int i,j,minimum; int checked[20]; for (i = 1; i <= n; ++i) { shortestPath[i] = 9999; checked[i] = 0; // Setting all vertices as unvisited }

shortestPath[sv] = 0;

for (j = 1; j <= n; ++j) {

minimum = -1; for (i = 1; i <= n; ++i) { if (!checked[i] && ((minimum == -1) || (shortestPath[i] < shortestPath[minimum]))) minimum = i; } checked[minimum] = 1; for (i = 1; i <= n; ++i) { if (distanceMatrix[minimum][i]) { if (shortestPath[minimum] + distanceMatrix[minimum][i] < shortestPath[i]) { shortestPath[i] = shortestPath[minimum] + distanceMatrix[minimum][i]; } } } } }

int main() { int i,j,from,to,distance; int n; int n_of_edges; int sourceVertex; printf("Enter the number of edges\t"); scanf("%d", &n_of_edges); for (i = 0; i < n_of_edges; ++i) for (j = 0; j < n_of_edges; ++j) distanceMatrix[i][j] = 0; n = -1; printf("Enter the edges in the order from--to--distance\n"); for (i = 0; i < n_of_edges; ++i) { scanf("%d%d%d", &from, &to, &distance); distanceMatrix[from][to] = distance;

n = findMax(from, findMax(to, n)); } printf("Enter the Source Vertex\t"); scanf("%d",&sourceVertex); findPath(sourceVertex,n); printPath(sourceVertex,n); getch(); return 0; }

Output of the Program

Enter the number of edges 10 Enter the edges in the order from--to--distance 1 2 10 231 145 242 423 452 439 354 536 517 Enter the Source Vertex 1 From To ShortestPath

110 128 139 145 157

Warshalls algorithm (Floyd warshall Algorithm) For finding all pairs of shortest paths. In a weighted directed graph, Floyd warshall algorithm can be used to find all pairs of shortest paths (distances between any pair of points) The algorithm is given below Algorithm Input: The adjacency matrix of a directed weighted graph. Output: a matrix d representing the shortest distances

18. for i=0 to n-1 19. for j=0 to i-1 20. If(w[i][j]==0) 21. d[i][j]= infinity 22. else 23. d[i][j]=W[i][j] 24. for i=0 to n-1 25. d[i][i]=0

9. for k = 0 to n-1 10. for i = 0 to n-1 11. for j = 0 to n-1 12. d[i][j] = min ( d[i][j], d[i][k]+d[k][j] ) 13. STOP

The complexity of the algorithm is O(n3),Where n is the number of vertices of the graph.

Exercises
13. Define graph.

14. Explain Direct and undirected graph. 15. How can we represent graphs? 16. Define sub graph. 17. Define path. 18. Explain Adjacency matrix with an example. 19. Explain Adjacency list with an example. 20. Explain DFS and BFS. 21. What is shortest path? 22. What is weighted graph? 23. Explain and Implement Dijkstra algorithm.

Exercises

12. Define graph. 13. Explain Direct and undirected graph. 14. How can we represent graphs? 15. Define sub graph. 16. Define path. 17. Explain Adjacency matrix with an example. 18. Explain Adjacency list with an example. 19. Explain DFS and BFS. 20. What is shortest path? 21. What is weighted graph? 22. Explain and Implement Dijkstra algorithm.

You might also like