Anda di halaman 1dari 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);
}