Breadth First Search is the technique to find the shortest distance between some starting node and the remaining nodes of the graph. This shortest distance is the minimum number of edges traversed in order to travel from the start node to the specific node being examined. It is called BFS because the distances are given breadth wise. It is the faster search technique as the representation of the nodes and the edges are in the form of adjacency list representation. We can also use this technique for searching.

Depth-first search (DFS) is an algorithm for traversing or searching a tree, tree structure, or graph. One starts at the root (selecting some node as the root in the graph case) and explores as far as possible along each branch before backtracking.

/******************************************************************

-> This Program is to implement Depth First search.

-> Data Structers:

Graph:Adjacency List

Stack:Array

-> This program works in Microsoft vc++ 6.0 environment.

*******************************************************************/

#include

int visit[100];

class graph

{

private:

int n;

graph*next;

public:

graph* read_graph(graph*);

void dfs(int); //dfs for a single node

void dfs(); //dfs of the entire graph

void ftraverse(graph*);

}*g[100];

int dfs_span_tree[100][100];

graph* graph::read_graph(graph*head)

{

int x;

graph*last;

head=last=NULL;

cout<<"Enter adjecent node ,-1 to stop:\n";

cin>>x;

while(x!=-1)

{

graph*NEW;

NEW=new graph;

NEW->n=x;

NEW->next=NULL;

if(head==NULL)

head=NEW;

else

last->next=NEW;

last=NEW;

cout<<"Enter adjecent node ,-1 to stop:\n";

cin>>x;

}

return head;

}

void graph::ftraverse(graph*h)

{

while(h!=NULL)

{

cout<n<<"->";

h=h->next;

}

cout<<"NULL"<

}

void graph::dfs(int x)

{

cout<<"node "<

visit[x]=1;

graph *p;

p=g[x];

while(p!=NULL)

{

int x1=p->n;

if(visit[x1]==0)

{

cout<<"from node "<

//Add the edge to the dfs spanning tree

dfs_span_tree[x][x1]=1;

dfs(x1);

}

p=p->next;

}

void graph::dfs()

{

int i;

cout<<"**********************************************************\n";

cout<<"This program is to implement dfs for an unweighted graph \n";

cout<<"**********************************************************\n";

cout<<"Enter the no of nodes ::";

cin>>n;

for(i=1;i<=n;i++)

g[i]=NULL;

for(i=1;i<=n;i++)

{

cout<<"Enter the adjacent nodes to node no. "<

cout<<"***************************************\n";

g[i]=read_graph(g[i]);

}

//display the graph

cout<<"\n\nThe entered graph is ::\n";

for(i=1;i<=n;i++)

{

cout<<" < "< ::";

ftraverse(g[i]);

}

for(i=1;i<=n;i++)

visit[i]=0; //mark all nodes as unvisited

cout<<"\nEnter the start vertex ::";

int start;

cin>>start;

for(i=1;i<=n;i++)

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

dfs_span_tree[i][j]=0;

cout<<"\nThe dfs for the above graph is ::\n";

dfs(start);

cout<<"\n\nThe required dfs spanning tree is ::\n";

for(i=1;i<=n;i++)

{

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

cout<

}

int main()

{

graph obj;

obj.dfs();

return 0;

}

Resources

Top Categories

Product

Company