Traversals

• Bredth First Search (BFS)
  • Given a graph G=(V,E) and s in V, explore the graph, finding the verticies closest to s first.
  • This will produce a "bredth first tree" with s as the root
  • New nodes are added to this tree as uniformly across the edge between explored and unexplored nodes.
  • We will add three fields to our verticies
    • color
      • white or 0 -> unexplored
      • grey or 1 -> explored, but not yet expanded
      • black or 2 -> explored and expanded.
    • Parent
      • Points to the node's parent in the bfs tree
      • not really needed, but we are probably doing a bfs for a reason
      • Like a later algorithm
    • Depth
      • Integer
      • How far down in the BFS tree this node is
  • Outline

    Color all nodes on the graph white
    Color the start node grey
    Put start node in the queue
    While the queue is not empty
         remove a node n from the queue
         color n black
         foreach child c of  n
            color c grey
    	parent of c =  n
    	enqueue c
    	    

  • The algorithm

    BFS(G,s), G=(V,E)
    ( 1) foreach vertex v in V-{s}
    ( 2)    color(v) = whilte
    ( 3)    depth(v) = inf
    ( 4)    parent(v) = NULL
    ( 5) color(s) = grey
    ( 6) Q.Enqueue(s)
    ( 7) depth(s) = 0
    ( 8) parent(s) = NULL
    ( 9) while !Q.IsEmpty()
    (10)    u = Q.Front()
    (11)    foreach v adjacient(u)
    (12)      if (color(v) == white) 
    (13)        color(v) = grey
    (14)        depth(v) = depth(v) + 1
    (15)        parent(v) = u
    (16)        Q.Enqueue(v)
    (17)     Dequeue(Q)
    (18)     color(u) = black;
    	

  • Analysis
    • We will visit each vertex in lines (1-8) once
    • We will also visit each vertex once in lines (9-18)
    • Both of these is O(|V|)
    • However, in line 11, we will look at each of the edges incident to the vertex under consideration
    • And we will do this for each edge in the graph (twice)
    • So this makes line 11-12 O(|E|)
    • Is this an add or multiply
    • It is an add, we don't look at all edges for all verticies we look only at the incedent edges for a given vertex
    • Therefore the algorithm is O(|E| + |V|)