Scribd
Upload
133 views4 pages

Exp 10 DFS

The document describes an implementation of depth-first search (DFS) on graphs. It explains that DFS starts at a given vertex and follows unvisited paths until reaching a vertex with no unvisited neighbors, then backtracks. The algorithm marks the current vertex visited, recursively explores adjacent unvisited vertices, and marks vertices as finished upon backtracking. Pseudocode is provided showing the steps of pushing vertices to a stack and popping them off to process neighbors until the stack is empty. An example run is shown tracking the discovery and finish order of vertices.

Uploaded by

enggeng7
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
133 views4 pages

Exp 10 DFS

The document describes an implementation of depth-first search (DFS) on graphs. It explains that DFS starts at a given vertex and follows unvisited paths until reaching a vertex with no unvisited neighbors, then backtracks. The algorithm marks the current vertex visited, recursively explores adjacent unvisited vertices, and marks vertices as finished upon backtracking. Pseudocode is provided showing the steps of pushing vertices to a stack and popping them off to process neighbors until the stack is empty. An example run is shown tracking the discovery and finish order of vertices.

Uploaded by

enggeng7
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 4

EXPERIMENT NO.

Aim :Implementations of Graph Traversal Depth First Search.


Theory :
DFS
-------Graphs may be represented by an array of adjacency lists. A Depth-First-Search of a graph starts at
a given vertex and then follows a path of un-visited vertices until it reaches a point where there are
non un visited vertices that are reachable.
Algorithm
--------1.Mark the current vertex,u,visited (color light blue), and enter it in the discovery order list.
2.For each vertex,v,adjacent to the current vertex,u.
3.If v has not been visited
4.Set parent of v to u.
5.Recursively apply this algorithm starting at v
6.Mark u finished (color it dark blue) and enter u into finish order list.

Operation
Visit 0
Visit 1
Visit 3
Visit 4
Finish 4

Adjacent Vertex
1,2,3,4
0,3,4
0,1,4
0,1,3

Discovery Order Finish Order


0
01
013
01234
4

Finish 3
Finish 1
Visit 2
Visit 5
Visit 6
Finish 6
Finish 5
Finish 2
Finish 0

43
431

0,5,6
2,6
2,5

01342
013425
0134256

4316
43165
431652
4316520

Depth-first search Algorithm


-----------------------------------The dfs algorithm progresses by expanding the staring node of G and thus going deeper and deeper
until a goal node is found, or until a node that has no children is encountered. When a dead-end is
reached, the algorithm backtracks, returning to the most recent node that has been completely
explored.
In other words, dfs begins at a starting node A which becomes the current node. Then it examines
each node N along a path p which begins at A. That is, we process a neighbour of A, then a
neighbour of neighbour of A, and so on. During the execution of the algorithm, if we reach a path
that has a node N that has already been processed, then we backtrack to the current node.
Otherwise, the unvisited (unprocessed) node becomes the current node.
The algorithm proceeds like this until we reach a dead-end (end of path p). On reaching the deadend, we backtrack to find another path p-dash. The algorithm terminates when backtracking leads
back to te starting node A. In the algorithm, edges that lead to a new vertex are called discovery
edges and edges that lead to an already visited vertex called back edges.
Observe that this algorithm is similar to the in-order traversal of a binary tree. Its implementation is
similar to that of the bfs algorithm but here we use a stack instead of a queue. Again, we use a
variable STATUS to represent the current state of the node.
Algorithm
-----------Step 1 : SET STATUS (Ready state) for each node in G.
Step 2 : Push the starting node A on the stack and set its STATUS=2 (waiting state)
Step 3 : Repeat Step 4 and 5 until STACK is empty
Step 4 : Pop the top node N. Process it and set its STATUS = 3 (processed state).
Step 5 : Push on to the stack all the neighbours of N that are in the ready state (whose
STATUS = 2 (Waiting state).
[END OF LOOP]
Step 6 : EXIT
Example
------------

Conclusion : Thus we have successfully implemented Graph menu driven program.

Program
#include<stdio.h>
void DFS(int);
int G[10][10],visited[10],n; //n is no of vertices and graph is sorted in array G[10][10]
int main()
{
int i,j;
printf("Enter number of vertices:");
scanf("%d",&n);
//read the adjecency matrix
printf("\nEnter adjecency matrix of the graph:");
for(i=0;i<n;i++)
for(j=0;j<n;j++)
scanf("%d",&G[i][j]);
//visited is initialized to zero
for(i=0;i<n;i++)
visited[i]=0;
DFS(0);
return 0;
}
void DFS(int i)
{
int j;
printf("\n%d",i);
visited[i]=1;

for(j=0;j<n;j++)
if(!visited[j]&&G[i][j]==1)
DFS(j);
}

You might also like