Breadth-First Traversal ( or Search ) for a graph is exchangeable to Breadth-First Traversal of a tree ( See method acting 2 of this post ). The only catch here is, unlike trees, graph may contain cycles, so we may come to the lapp node again. To avoid processing a node more than once, we use a boolean visit array. For simplicity, it is assumed that all vertices are approachable from the starting vertex. For exemplar, in the adopt graph, we start traversal from vertex 2. When we come to vertex 0, we look for all adjacent vertices of it. 2 is besides an adjacent vertex of 0. If we don ’ thymine notice visited vertices, then 2 will be processed again and it will become a non-terminating procedure. A Breadth-First traversal of the surveil graph is 2, 0, 3, 1.

Following are the implementations of bare Breadth-First Traversal from a given source.
The implementation uses an adjacency tilt representation of graph. STL ‘ randomness list container is used to store lists of adjacent nodes and the queue of nodes needed for BFS traversal .

Table of Contents

C++




#include using namespace std; class Graph {      int V;                   vectorint>> adj;   public :      Graph( int V);            void addEdge( int v, int w);           void BFS( int s);  }; Graph::Graph( int V) {      this ->V = V;      adj.resize(V); } void Graph::addEdge( int v, int w) {      adj[v].push_back(w); } void Graph::BFS( int s) {           vector< bool > visited;      visited.resize(V, false );           list< int > queue;           visited[s] = true ;      queue.push_back(s);      while (!queue.empty())      {                   s = queue.front();          cout << s << " " ;          queue.pop_front();                                     for ( auto adjecent: adj[s])          {              if (!visited[adjecent])              {                  visited[adjecent] = true ;                  queue.push_back(adjecent);              }          }      } } int main() {           Graph g(4);      g.addEdge(0, 1);      g.addEdge(0, 2);      g.addEdge(1, 2);      g.addEdge(2, 0);      g.addEdge(2, 3);      g.addEdge(3, 3);      cout << "Following is Breadth First Traversal "           << "(starting from vertex 2) \n" ;      g.BFS(2);      return 0; }



Java




import java.io.*; import java.util.*; class Graph {      private int V;        private LinkedList adj[];           Graph( int v)      {          V = v;          adj = new LinkedList[v];          for ( int i= 0 ; i              adj[i] = new LinkedList();      }           void addEdge( int v, int w)      {          adj[v].add(w);      }           void BFS( int s)      {                            boolean visited[] = new boolean [V];                   LinkedList queue = new LinkedList();                   visited[s]= true ;          queue.add(s);          while (queue.size() != 0 )          {                           s = queue.poll();              System.out.print(s+ " " );                                                     Iterator i = adj[s].listIterator();              while (i.hasNext())              {                  int n = i.next();                  if (!visited[n])                  {                      visited[n] = true ;                      queue.add(n);                  }              }          }      }           public static void main(String args[])      {          Graph g = new Graph( 4 );          g.addEdge( 0 , 1 );          g.addEdge( 0 , 2 );          g.addEdge( 1 , 2 );          g.addEdge( 2 , 0 );          g.addEdge( 2 , 3 );          g.addEdge( 3 , 3 );          System.out.println( "Following is Breadth First Traversal " +                             "(starting from vertex 2)" );          g.BFS( 2 );      } }



Python3




from collections import defaultdict class Graph:           def __init__( self ):                   self .graph = defaultdict( list )           def addEdge( self ,u,v):          self .graph[u].append(v)           def BFS( self , s):                   visited = [ False ] * ( max ( self .graph) + 1 )                   queue = []                            queue.append(s)          visited[s] = True          while queue:                                        s = queue.pop( 0 )              print (s, end = " " )                                                                  for i in self .graph[s]:                  if visited[i] = = False :                      queue.append(i)                      visited[i] = True g = Graph() g.addEdge( 0 , 1 ) g.addEdge( 0 , 2 ) g.addEdge( 1 , 2 ) g.addEdge( 2 , 0 ) g.addEdge( 2 , 3 ) g.addEdge( 3 , 3 ) print ( "Following is Breadth First Traversal"                    " (starting from vertex 2)" ) g.BFS( 2 )



C#




using System; using System.Collections.Generic; using System.Linq; using System.Text; class Graph{      private int _V; LinkedList< int >[] _adj; public Graph( int V) {      _adj = new LinkedList< int >[V];      for ( int i = 0; i < _adj.Length; i++)      {          _adj[i] = new LinkedList< int >();      }      _V = V; } public void AddEdge( int v, int w) {              _adj[v].AddLast(w); } public void BFS( int s) {                     bool [] visited = new bool [_V];      for ( int i = 0; i < _V; i++)          visited[i] = false ;                LinkedList< int > queue = new LinkedList< int >();                     visited[s] = true ;      queue.AddLast(s);              while (queue.Any())      {                                     s = queue.First();          Console.Write(s + " " );          queue.RemoveFirst();                                                       LinkedList< int > list = _adj[s];          foreach ( var val in list)                      {              if (!visited[val])              {                  visited[val] = true ;                  queue.AddLast(val);              }          }      } } static void Main( string [] args) {      Graph g = new Graph(4);           g.AddEdge(0, 1);      g.AddEdge(0, 2);      g.AddEdge(1, 2);      g.AddEdge(2, 0);      g.AddEdge(2, 3);      g.AddEdge(3, 3);           Console.Write( "Following is Breadth First " +                    "Traversal(starting from " +                    "vertex 2)\n" );      g.BFS(2); } }



Output

Following is Breadth First Traversal (starting from vertex 2) 
2 0 3 1 

Time Complexity: O ( V+E ), where V is the number of nodes and E is the number of edges.
Auxiliary Space: O ( V ) Illustration :  bfs1 bfs2 bfs3 bfs4 bfs6 bfs7 bfs8 bfs9 bfs10 bfs11 note that the above code traverses only the vertices reachable from a given beginning vertex. All the vertices may not be approachable from a given vertex ( for case Disconnected graph ). To print all the vertices, we can modify the BFS function to do traversal starting from all nodes one by one ( Like the DFS modified adaptation ). hypertext transfer protocol : //youtu.be/0u78hx-66Xk You may like to see below also : Please write comments if you find anything wrong, or you want to share more information about the topic discussed above.

My Personal Notes

arrow_drop_up

ใส่ความเห็น

อีเมลของคุณจะไม่แสดงให้คนอื่นเห็น