Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
125 views

BFS DFS

The document discusses and provides code examples for Breadth-First Search (BFS), Depth-First Search (DFS), and implementations of both algorithms using queues, stacks, and linked lists. BFS uses a queue to search all nodes at the current level before proceeding to the next level, while DFS uses a stack to search nodes in a depthward motion from the root. Code examples in C demonstrate traversing graph and tree data structures with BFS and DFS.

Uploaded by

rajsathyams
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as DOC, PDF, TXT or read online on Scribd
125 views

BFS DFS

The document discusses and provides code examples for Breadth-First Search (BFS), Depth-First Search (DFS), and implementations of both algorithms using queues, stacks, and linked lists. BFS uses a queue to search all nodes at the current level before proceeding to the next level, while DFS uses a stack to search nodes in a depthward motion from the root. Code examples in C demonstrate traversing graph and tree data structures with BFS and DFS.

Uploaded by

rajsathyams
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as DOC, PDF, TXT or read online on Scribd
You are on page 1/ 5

BFS & DFS

Breadth First Search #include <stdio.h> #define N 10

Page 1 of 5

void bfs(int adj[][N],int visited[],int start) { int q[N],rear=-1,front=-1,i; q[++rear]=start; visited[start]=1; while(rear != front) { start = q[++front]; if(start==9) printf("10\t"); else printf("%c \t",start+49); //change to 65 in case of alphabets for(i=0;i<N;i++) { if(adj[start][i] && !visited[i]) { q[++rear]=i; visited[i]=1; } }

} }

int main() { int visited[N]={0}; int adj[N][N]={{0,1,1,0,0,0,0,0,0,1}, {0,0,0,0,1,0,0,0,0,1}, {0,0,0,0,1,0,1,0,0,0}, {1,0,1,0,0,1,1,0,0,1}, {0,0,0,0,0,0,1,1,0,0}, {0,0,0,1,0,0,0,1,0,0}, {0,0,0,0,0,0,0,1,1,1}, {0,0,1,0,0,0,0,0,0,0}, {0,0,0,1,0,0,0,0,0,0}, {0,0,1,0,0,0,0,1,1,0}}; bfs(adj,visited,0); return 0; }

BFS & DFS


Depth First Search #include<stdio.h> #define MAX 5 int dfs(int adj[][MAX],int visited[],int start) { int stack[MAX]; int top=-1,i; printf("%c-",start+65); visited[start]=1; stack[++top]=start; while(top!=-1) { start=stack[top]; for(i=0;i<MAX;i++) { if(adj[start][i]&&visited[i]==0) { stack[++top]=i; printf("%c-",i+65); visited[i]=1; break; } } if(i==MAX) top--; } return 0; } int main() {

Page 2 of 5

int adj[MAX][MAX]={{0,0,1,1,0},{0,0,0,0,0},{0,1,0,1,1},{0,0,0,0,1},{0,0,0,1,0}}; int visited[MAX]={0}; printf("DFS Traversal : "); dfs(adj,visited,0); printf("\n"); } return 0;

BFS & DFS

Page 3 of 5

BFS LIST /*Program that implements breadth first search algorithm*/ #include <stdio.h> #include <conio.h> #include <alloc.h> #define TRUE 1 #define FALSE 0 #define MAX 8 struct node { int data ; struct node *next ; }; int visited[MAX] ; int q[8] ; int front, rear ; void bfs ( int, struct node ** ) ; struct node * getnode_write ( int ) ; void addqueue ( int ) ; int deletequeue( ) ; int isempty( ) ; void del ( struct node * ) ; void main( ) { struct node *arr[MAX] ; struct node *v1, *v2, *v3, *v4 ; int i ; clrscr( ) ; v1 = getnode_write ( 2 ) ; arr[0] = v1 ; v1 -> next = v2 = getnode_write ( 3 ) ; v2 -> next = NULL ; v1 = getnode_write ( 1 ) ; arr[1] = v1 ; v1 -> next = v2 = getnode_write ( 4 ) ; v2 -> next = v3 = getnode_write ( 5 ) ; v3 -> next = NULL ; v1 = getnode_write ( 1 ) ; arr[2] = v1 ; v1 -> next = v2 = getnode_write ( 6 ) ; v2 -> next = v3 = getnode_write ( 7 ) ;

v3 -> next = NULL ; v1 = getnode_write ( 2 ) ; arr[3] = v1 ; v1 -> next = v2 = getnode_write ( 8 ) ; v2 -> next = NULL ; v1 = getnode_write ( 2 ) ; arr[4] = v1 ; v1 -> next = v2 = getnode_write ( 8 ) ; v2 -> next = NULL ; v1 = getnode_write ( 3 ) ; arr[5] = v1 ; v1 -> next = v2 = getnode_write ( 8 ) ; v2 -> next = NULL ; v1 = getnode_write ( 3 ) ; arr[6] = v1 ; v1 -> next = v2 = getnode_write ( 8 ) ; v2 -> next = NULL ; v1 = getnode_write ( 4 ) ; arr[7] = v1 ; v1 -> next = v2 = getnode_write ( 5 ) ; v2 -> next = v3 = getnode_write ( 6 ) ; v3 -> next = v4 = getnode_write ( 7 ) ; v4 -> next = NULL ; front = rear = -1 ; bfs ( 1, arr ) ; for ( i = 0 ; i < MAX ; i++ ) del ( arr[i] ) ; getch( ) ; } void bfs ( int v, struct node **p ) { struct node *u ; visited[v - 1] = TRUE ; printf ( "%d\t", v ) ; addqueue ( v ) ; while ( isempty( ) == FALSE ) { v = deletequeue( ) ; u=*(p+v-1); while ( u != NULL )

BFS & DFS


{ if ( visited [ u -> data - 1 ] == FALSE ) { addqueue ( u -> data ) ; visited [ u -> data - 1 ] = TRUE ; printf ( "%d\t", u -> data ) ; } u = u -> next ; } } } struct node * getnode_write ( int val ) { struct node *newnode ; newnode = ( struct node * ) malloc ( sizeof ( struct node ) ) ; newnode -> data = val ; return newnode ; } void addqueue ( int vertex ) { if ( rear == MAX - 1 ) { printf ( "\nQueue Overflow." ) ; exit( ) ; } rear++ ; q[rear] = vertex ; if ( front == -1 ) front = 0 ; } int deletequeue( ) { int data ; if ( front == -1 ) { printf ( "\nQueue Underflow." ) ; exit( ) ; } data = q[front] ; if ( front == rear ) front = rear = -1 ; else front++ ; return data ; } int isempty( ) { if ( front == -1 ) return TRUE ; return FALSE ; } void del ( struct node *n ) { struct node *temp ; while ( n != NULL ) { temp = n -> next ; free ( n ) ; n = temp ; } } DFS- LIST #include <stdio.h> typedef struct node { int value; struct node *right; struct node *left; } mynode; mynode *root; add_node(int value);

Page 4 of 5

void levelOrderTraversal(mynode *root); int main(int argc, char* argv[]) { root = NULL; add_node(5); add_node(1); add_node(-20); add_node(100); add_node(23); add_node(67); add_node(13); printf("\n\n\nLEVEL ORDER TRAVERSAL\n\n"); levelOrderTraversal(root); getch();

BFS & DFS


} // Function to add a new node... add_node(int value) { mynode *prev, *cur, *temp; temp = malloc(sizeof(mynode)); temp->value = value; temp->right = NULL; temp->left = NULL; if(root == NULL) { printf("\nCreating the root..\n"); root = temp; return; } prev = NULL; cur = root; while(cur != NULL) { prev = cur; //cur = (value < cur->value) ? cur->left:cur>right; if(value < cur->value) { cur = cur->left; } else { cur = cur->right; } } if(value < prev->value) { prev->left = temp; } else { prev->right = temp; } } // Level order traversal.. void levelOrderTraversal(mynode *root) { mynode *queue[100] = {(mynode *)0}; // Important to initialize! int size = 0; int queue_pointer = 0; while(root) { printf("[%d] ", root->value); if(root->left) { queue[size++] = root->left; } if(root->right) { queue[size++] = root->right;

Page 5 of 5
} root = queue[queue_pointer++]; } }

You might also like