Depth-First and Breadth-First Searches

• Two classic graph searching algorithms.
• Each attempts to visit every vertex in a graph.
• Both are labeled exhaustive search by our author.
• Depth First Search
  • The general idea is to get as "far" away from a starting point as possible (explore in depth)
  • I'm going to use the algorithm out of CLRS

  • DFS(G=<V,E>)
    
     for each vertex u ∈ V do
        color[u] ← white
        π[u] ← NULL
     time ← 0
     for each vertex u ∈ V do
         if color[u] = white
            DFS-VISIT(u)
    
    
    DFS-VISIT(u)
    
     color[u] ← gray
     time ← time + 1
     d[u] ← time
     for each vertex v ∈ Adj(u) do
        if color[u] = white
             π[v] = u
             DFS-VISIT(v)
     color[u] ← black
     f[u] ← time ← time + 1
    
    	  

  • Mark the verticies as unvisited. (white)
  • π represents the search tree
  • d represents the depth at which a node is discovered
  • f represents the depth at which a node is completely processed
  • Later mark the verticies as discovered but not yet visited
  • After a node is completely explored, color it black.
  • Disjoint subgraphs will be explored one at a time.
  • Does it terminate?
  • Does it work? (IE Visits every node)
  • What is the time performance?
  • O(|V|) space performance! Why?
• Breadth First Search (BFS)
  • Explore as "close" to the starting as possible.
  • Again from CLRS

    BFS(G,s)
    
     for each vertex u ∈ V - {s} do
          color[u] ← white
          d[u] ← ∞
          π[u] ← NULL
     color[s] ← gray
     d[s] ← 0
     π[s] ← NULL
     Q ← Ø
     Q.Enqueue(s)
     while Q ≠ Ø do
         u ← Q.Dequeue()
         for each v ∈ adj(u) do
             if color[v] = white
                   color[v] ← gray
                   d[v] ← d[u] + 1
                   π[v] = u
                   Q.Enqueue(v)
         color[u] ← black
    
    	 

    • Lines 1-9 are initialization, but O(|V|)
    • Line 10 is O(|V|) for all verticies connected to s
    • (We could replace this with two routines like DFS if we wish.)
    • Does this terminate?
    • Does it work?
    • Performance?