Graph traversal is a generalization of tree traversal except we have to keep track of the visited vertices.

Transcription

1 Traversal Techniques for Graphs Graph traversal is a generalization of tree traversal except we have to keep track of the visited vertices. Applications: Strongly connected components, topological sorting, critical path analysis... Breadth first search (BFS) Depth first search (DFS) They prove the basis of most simple, efficient graph algorithms. 1

2 Breadth First Search (BFS): Search for all the vertices that can be reached from a given starting vertex (Reachability Problem) Algorithm BFS: Start at a vertex v mark it as reached The vertex v is, as yet, unexplored when all the vertices adjacent to it (connected by an edge) have been visited, v has been explored (reached). Collect all the unvisited vertices adjacent to v and add them to a list. Take a vertex from the list and repeat the process When there are no vertices left in the list they have all been explored (reached). This yields the set of vertices that are reachable from the start vertex v. 2

3 Breadth First Search AlgorithmBF S(v : vertex; G : Graph){ //perform a breadth first search of //G, starting with vertex v //a vertex i is marked by setting //visited[i] := 1, initially visited[i] = 0; visited[v] = 1; u = v; MakeEmpty(Q); Insert(Q, v); while(n ot IsEmpty(Q)){ for all vertices w adjacent to u { if(v isited[w] == 0){ Insert(Q, w); visited[w] = 1; } } if (N ot IsEmpty(Q)) u = Delete(Q); }} 3

4 Example:Breadth first search Example n = 8, e = 10 Q Reached (Explored) Visited 2, 3 3, 4, 5 4, 5, 6, 7 5, 6, 7, 8 6, 7, 8 7, 8 8 4

5 Exercise: 1. Apply BFS algorithm on the following tree and trace the queue entries. Q Reached (Explored) Visited 5

6 2.What are reachable vertices starting from 1, from 4, from 3? Correctness of BFS Theorem: vertices. Algorithm BFS visits all reachable Proof [by induction on length of shortest path]: Suppose d(v, w) is the length (number of edges) of the shortest path from vertex v to a reachable vertex w. Basic step : Clearly, all w with d(v, w) 1 are visited. 6

7 Hypothesis : Assume all vertices w with d(v, w) r are visited. Inductive step : We now show that all w with d(v, w) r + 1 are also visited. Suppose that d(v, w) = r + 1 for some w, and let u be a vertex adjacent to w, u v and r 1. Then d(v, u) = r (shortest path) and immediately prior to u being visited by BFS, u is put on the Queue. Since the algorithm only stops when the Queue is empty, at some stage u is taken off the Queue and is explored and thus visits w. The only way for w not to be visited is if it is not reachable. 7

8 Complexity of BFS Theorem: Let T (n, e) and S(n, e) be the maximum time and maximum space required by BFS on any Graph with n vertices and e edges. T (n, e) = O(n + e) and S(n, e) = O(n) if G is represented by an adjacency list and T (n, e) = O(n 2 ) and S(n, e) = O(n) if adjacency matrix is used. Proof : Vertices only get added to the queue once. Vertex v is never in the queue so at most (n 1) inserts are made. So Queue space is (n 1) hence S(n, e) = O(n) and Θ(n) is needed for the array visited. Hence S(n, e) = O(n). If adjacency list is used then the neighbours can be found in time d(u) where d(u) is the degree of u. Exploring u costs Θ(d(u)) and the total cost for all edges is O( d(u)) = O(e). Visited is initialized in O(n) time. Hence T (n) = O(n + e). For adjacency matrices d(u) is replaced by Θ(n). Hence T (n, e) = O(n 2 ). 8

9 Applications of BFS Connected Components If G is connected undirected graph then all vertices of G are visited on first call of BFS. If G is not connected then we need at least two calls to BFS. An extension of BFS algorithm can be designed to find all the connected components. Spanning Trees A graph G has a spanning tree if and only if G is connected. A slight modification of BFS can be made to compute a spanning tree. Tree traversal Level by level traversal of a tree 9

10 Algorithm: Connected Components A complete traversal of an un-connected graph can be made by repeatedly calling BFS each time with an unvisited starting vertex. Algorithm BF T (G : Graph; n : integer){ //Breadth first traversal of G V isited : array[1...n] of boolean; } for(i = 1; i <= n; i + +) V isited[i] = 0; for(i = 1; i <= n; i + +) if(v isited[i] = 0) BF S(i, G); If G is connected then all vertices are visited in the first call of BFS. 10

11 Algorithm: Spanning Tree An extension of algorithm BFS Algorithm BF S Span(v : vertex; G : Graph){ visited[v] = 1; u = v; MakeEmpty(Q); Insert(Q, v); t = {}; //empty tree; while(n ot IsEmpty(Q)){ for all vertices w adjacent to u{ if V isited[w] = 0 { Insert(Q, w); V isited[w] = 1; t = t {(u, w)}; //add the forward edges }} if(not IsEmpty(Q)) u = Delete(Q); } } 11

12 BFS Spanning Tree Example 12

13 BFS for Trees Algorithm LevelByLevel(T : T ree){ //where Queue has data of type Tree. Q : Queue; T emp : T ree; MakeEmpty(Q); Insert(Q, T ); while(n ot Empty(Q)){ T emp = Delete(Q); P rint(data(temp)); Insert(Q, LChild(T emp)); Insert(Q, RChild(T emp)); } } 13