Which Side of Dipstick to Read Traverse

Graph traversals

Graph traversal means visiting every vertex and edge exactly in one case in a well-defined guild. While using certain graph algorithms, you must ensure that each vertex of the graph is visited exactly once. The guild in which the vertices are visited are of import and may depend upon the algorithm or question that you lot are solving.

During a traversal, information technology is important that you lot track which vertices have been visited. The most mutual way of tracking vertices is to mark them.

Breadth First Search (BFS)

There are many means to traverse graphs. BFS is the most ordinarily used approach.

BFS is a traversing algorithm where y'all should commencement traversing from a selected node (source or starting node) and traverse the graph layerwise thus exploring the neighbour nodes (nodes which are directly connected to source node). Y'all must and so move towards the adjacent-level neighbour nodes.

As the name BFS suggests, you are required to traverse the graph breadthwise equally follows:

1. First move horizontally and visit all the nodes of the current layer
2. Move to the next layer

Consider the post-obit diagram.

The altitude between the nodes in layer 1 is comparitively bottom than the distance between the nodes in layer 2. Therefore, in BFS, yous must traverse all the nodes in layer 1 before you motion to the nodes in layer 2.

Traversing kid nodes

A graph can contain cycles, which may bring yous to the aforementioned node again while traversing the graph. To avoid processing of aforementioned node again, use a boolean array which marks the node after it is candy. While visiting the nodes in the layer of a graph, store them in a way such that you tin can traverse the corresponding child nodes in a similar order.

In the earlier diagram, start traversing from 0 and visit its child nodes i, 2, and 3. Store them in the social club in which they are visited. This will let y'all to visit the child nodes of ane beginning (i.eastward. four and 5), so of ii (i.due east. 6 and 7), and and then of 3 (i.e. 7) etc.

To make this process piece of cake, use a queue to store the node and mark it as 'visited' until all its neighbours (vertices that are directly continued to it) are marked. The queue follows the First In Outset Out (FIFO) queuing method, and therefore, the neigbors of the node will be visited in the order in which they were inserted in the node i.e. the node that was inserted first will be visited showtime, so on.

Pseudocode

          BFS (One thousand, s)                   //Where G is the graph and s is the source node       let Q be queue.       Q.enqueue( s ) //Inserting s in queue until all its neighbour vertices are marked.        marker due south equally visited.       while ( Q is not empty)            //Removing that vertex from queue,whose neighbour will be visited at present            v  =  Q.dequeue( )            //processing all the neighbours of v             for all neighbours w of five in Graph Thou                if w is not visited                          Q.enqueue( w )             //Stores westward in Q to farther visit its neighbour                         marking due west as visited.                  

Traversing process

The traversing will start from the source node and push due south in queue. s will exist marked as 'visited'.

Get-go iteration

• s will be popped from the queue
• Neighbors of s i.east. 1 and 2 volition exist traversed
• i and 2, which accept non been traversed earlier, are traversed. They volition be:
  • Pushed in the queue
  • 1 and 2 volition be marked as visited

2nd iteration

• 1 is popped from the queue
• Neighbors of 1 i.eastward. southward and three are traversed
• due south is ignored because information technology is marked as 'visited'
• 3, which has not been traversed earlier, is traversed. Information technology is:
  • Pushed in the queue
  • Marked as visited

3rd iteration

• 2 is popped from the queue
• Neighbors of 2 i.due east. southward, 3, and 4 are traversed
• 3 and s are ignored because they are marked as 'visited'
• four, which has not been traversed earlier, is traversed. It is:
  • Pushed in the queue
  • Marked as visited

Fourth iteration

• 3 is popped from the queue
• Neighbors of 3 i.e. 1, 2, and 5 are traversed
• 1 and 2 are ignored because they are marked as 'visited'
• 5, which has non been traversed earlier, is traversed. It is:
  • Pushed in the queue
  • Marked as visited

Fifth iteration

• 4 will be popped from the queue
• Neighbors of 4 i.due east. 2 is traversed
• two is ignored because it is already marked as 'visited'

Sixth iteration

• 5 is popped from the queue
• Neighbors of five i.e. iii is traversed
• 3 is ignored because it is already marked as 'visited'

The queue is empty and it comes out of the loop. All the nodes have been traversed by using BFS.

If all the edges in a graph are of the same weight, then BFS can likewise be used to find the minimum distance between the nodes in a graph.

Case

As in this diagram, offset from the source node, to find the distance between the source node and node i. If you do non follow the BFS algorithm, you can go from the source node to node 2 and then to node one. This approach will summate the distance between the source node and node i as 2, whereas, the minimum distance is actually 1. The minimum distance can be calculated correctly by using the BFS algorithm.

Complexity

The time complication of BFS is O(V + E), where V is the number of nodes and Due east is the number of edges.

Applications

ane. How to decide the level of each node in the given tree?

As you know in BFS, you traverse level wise. Y'all can also use BFS to decide the level of each node.

Implementation

                      vector <int> v[10] ;   //Vector for maintaining adjacency list explained higher up     int level[10]; //To determine the level of each node     bool vis[10]; //Mark the node if visited      void bfs(int south) {         queue <int> q;         q.push button(s);         level[ s ] = 0 ;  //Setting the level of the source node every bit 0         vis[ s ] = true;         while(!q.empty())         {             int p = q.front();             q.pop();             for(int i = 0;i < v[ p ].size() ; i++)             {                 if(vis[ v[ p ][ i ] ] == false)                 {             //Setting the level of each node with an increment in the level of parent node                     level[ 5[ p ][ i ] ] = level[ p ]+i;                                       q.push(5[ p ][ i ]);                      vis[ v[ p ][ i ] ] = truthful;       }             }         }     }                  

This code is similar to the BFS code with only the following difference:
level[ 5[ p ][ i ] ] = level[ p ]+i;

In this lawmaking, while yous visit each node, the level of that node is set with an increase in the level of its parent node. This is how the level of each node is determined.

                      node                            level [node]                   s (source node)               0                 1                            one                 ii                            1                 three                            ii                 iv                            2                 5                            2                 half dozen                            two                 7                            three                  

2. 0-one BFS

This type of BFS is used to find the shortest distance between two nodes in a graph provided that the edges in the graph have the weights 0 or 1. If you use the BFS explained earlier in this commodity, you will become an wrong result for the optimal distance betwixt 2 nodes.

In this approach, a boolean array is not used to mark the node because the condition of the optimal distance will exist checked when you visit each node. A double-ended queue is used to store the node. In 0-1 BFS, if the weight of the edge = 0, then the node is pushed to the front of the dequeue. If the weight of the border = 1, then the node is pushed to the back of the dequeue.

Implementation

Here, edges[ 5 ] [ i ] is an adjacency listing that exists in the form of pairs i.eastward. edges[ v ][ i ].first will contain the node to which 5 is connected and edges[ v ][ i ].2d will incorporate the distance between 5 and edges[ five ][ i ].first .

Q is a double-ended queue. The distance is an array where, distance[ v ] will incorporate the distance from the start node to v node. Initially the altitude defined from the source node to each node is infinity.

          void bfs (int start) {             deque <int > Q;     //Double-concluded queue             Q.push_back( start);              distance[ start ] = 0;                    while( !Q.empty ())             {                 int 5 = Q.front( );                 Q.pop_front();                  for( int i = 0 ; i < edges[v].size(); i++)                {   /* if distance of neighbor of v from outset node is greater than sum of distance of v from commencement node and edge weight betwixt v and its neighbour (distance between v and its neighbour of five) ,then change information technology */                         if(distance[ edges[ v ][ i ].first ] > distance[ v ] + edges[ v ][ i ].second )                  {                      distance[ edges[ five ][ i ].first ] = distance[ 5 ] + edges[ 5 ][ i ].second;                  /*if border weight between v and its neighbor is 0 then button information technology to forepart of         double concluded queue else push it to back*/                      if(edges[ v ][ i ].second == 0)                     {                         Q.push_front( edges[ v ][ i ].first);                     }                     else                     {                             Q.push_back( edges[ v ][ i ].get-go);                      }                 }               }            }     }                  

Let's sympathise this code with the following graph:

The adjacency listing of the graph will be equally follows:
Here 's' is considered to be 0 or source node.

0 -> i -> three -> ii
edges[ 0 ][ 0 ].first = 1 , edges[ 0 ][ 0 ].2nd = 1
edges[ 0 ][ 1 ].start = 3 , edges[ 0 ][ 1 ].second = 0
edges[ 0 ][ 2 ].beginning = two , edges[ 0 ][ 2 ].second = ane

i -> 0 -> 4
edges[ 1 ][ 0 ].first = 0 , edges[ 1 ][ 0 ].second = 1
edges[ 1 ][ 1 ].first = 4 , edges[ 1 ][ 1 ].second = 0

2 -> 0 -> three
edges[ 2 ][ 0 ].first = 0 , edges[ ii ][ 0 ].second = 0
edges[ 2 ][ 1 ].first = iii , edges[ 2 ][ ane ].second = 0

3 -> 0 -> two -> 4
edges[ 3 ][ 0 ].first = 0 , edges[ 3 ][ 0 ].second = 0
edges[ 3 ][ 2 ].first = ii , edges[ iii ][ 2 ].second = 0
edges[ 3 ][ iii ].kickoff = four , edges[ iii ][ 3 ].second = 0

four -> 1 -> 3
edges[ 4 ][ 0 ].first = 1 , edges[ 4 ][ 0 ].2nd = 0
edges[ iv ][ 1 ].first = 3 , edges[ iv ][ ane ].second = 0

If you use the BFS algorithm, the result volition exist wrong because it will testify you the optimal altitude between s and node 1 and s and node two equally 1 respectively. This is considering it visits the children of due south and calculates the distance between s and its children, which is 1. The bodily optimal distance is 0 in both cases.

Processing

Starting from the source node, i.e 0, information technology will motion towards one, two, and 3. Since the edge weight betwixt 0 and i and 0 and ii is 1 respectively, 1 and 2 will be pushed to the dorsum of the queue. Even so, since the edge weight between 0 and 3 is 0, iii will pushed to the front of the queue. The distance volition be maintained in distance array appropriately.

iii will then be popped from the queue and the same process will be applied to its neighbours, and then on.

Contributed by: Prateek Garg

gorewhour1999.blogspot.com

Source: https://www.hackerearth.com/practice/algorithms/graphs/breadth-first-search/tutorial/

Share this post