Documents
Resources
Learning Center
Upload
Plans & pricing Sign in
Sign Out

Graph traversals Breadth first search

VIEWS: 22 PAGES: 9

									                Graph traversals                                              Breadth first search
• In this lecture, we look at two ways of visiting all vertices   BFS starting from vertex v:
  in a graph: breadth-first search and depth-first search.
• Traversal of the graph is used to perform tasks such as
                                                                  create a queue Q
  searching for a certain node
                                                                  mark v as visited and put v into Q
• It can also be slightly modified to search for a path
  between two nodes, check if the graph is connected, check       while Q is non-empty
  if it contains loops, and so on.                                  remove the head u of Q
                                                                    mark and enqueue all (unvisited)
                                                                    neighbours of u




               BFS starting from A:                                             BFS starting from A:

                                               Q={A}                                                        Q={A}
                                                                                                            Q={B,G}
                                           D                                                            D
                 B           C                                                    B             C


       A                          E                                      A                          E
                       F                                                                F


                 G                                                                G




               BFS starting from A:                                             BFS starting from A:

                                               Q={A}                                                        Q={A}
                                               Q={B,G}                                                      Q={B,G}
                                           D                                                            D
                 B           C                 Q={G,C,F}                          B             C           Q={G,C,F}
                                                                                                            Q={C,F}
       A                          E                                      A                          E
                       F                                                                F


                 G                                                                G




                                                                                                                        1
           BFS starting from A:                   BFS starting from A:

                                  Q={A}                                Q={A}
                                  Q={B,G}                              Q={B,G}
                              D                                    D
            B        C            Q={G,C,F}        B       C           Q={G,C,F}
                                  Q={C,F}                              Q={C,F}
     A                            Q={F,D,E}   A                        Q={F,D,E}
                 F       E                             F       E
                                                                       Q={D,E}

            G                                      G




           BFS starting from A:                   BFS starting from A:

                                  Q={A}                                Q={A}
                                  Q={B,G}                              Q={B,G}
                              D                                    D
            B        C            Q={G,C,F}        B       C           Q={G,C,F}
                                  Q={C,F}                              Q={C,F}
     A                            Q={F,D,E}   A                        Q={F,D,E}
                 F       E                             F       E
                                  Q={D,E}                              Q={D,E}
                                  Q={E}                                Q={E}
            G                                      G                   Q={}




                Simple DFS                        DFS starting from A:

DFS starting from vertex v:                                            S={A}

                                                                   D
create a stack S                                   B       C
mark v as visited and push v onto S
while S is non-empty
  peek at the top u of S                      A                E
                                                       F
  if u has an (unvisited)neighbour w,
  mark w and push it onto S
  else pop S                                       G




                                                                                   2
    DFS starting from A:                   DFS starting from A:

                         S={A}                                  S={A}
                         S={A,B}                                S={A,B}
                     D                                      D
     B       C                              B       C           S={A,B,C}


A                E                     A                E
         F                                      F


     G                                     G




    DFS starting from A:                   DFS starting from A:

                         S={A}                                  S={A}
                         S={A,B}                                S={A,B}
                     D                                      D
     B       C           S={A,B,C}          B       C           S={A,B,C}
                         S={A,B,C,D}                            S={A,B,C,D}
A                                      A                        S={A,B,C}
         F       E                              F       E


     G                                      G




    DFS starting from A:                   DFS starting from A:

                         S={A}                                  S={A}
                         S={A,B}                                S={A,B}
                     D                                      D
     B       C           S={A,B,C}          B       C           S={A,B,C}
                         S={A,B,C,D}                            S={A,B,C,D}
A                        S={A,B,C}     A                        S={A,B,C}
         F       E                              F       E
                         S={A,B,C,E}                            S={A,B,C,E}
                                                                S={A,B,C, E, F}
     G                                      G




                                                                                  3
    DFS starting from A:                       DFS starting from A:

                         S={A}                                      S={A,B,C,E,F}
                         S={A,B}
                     D                                          D
     B       C           S={A,B,C}              B       C
                         S={A,B,C,D}
A                        S={A,B,C}         A
         F       E                                  F       E
                         S={A,B,C,E}
                         S={A,B,C,E,F}
     G                   S={A,B,C,E,F,G}        G




    DFS starting from A:                       DFS starting from A:

                         S={A,B,C,E,F}                              S={A,B,C,E,F}
                         S={A,B,C,E}                                S={A,B,C,E}
                     D                                          D
     B       C                                  B       C           S={A,B,C}


A                E                         A                E
         F                                          F


     G                                          G




    DFS starting from A:                       DFS starting from A:

                         S={A,B,C,E,F}                              S={A,B,C,E,F}
                         S={A,B,C,E}                                S={A,B,C,E}
                     D                                          D
     B       C           S={A,B,C}              B       C           S={A,B,C}
                         S={A,B}                                    S={A,B}
A                                          A                        S={A}
         F       E                                  F       E


     G                                          G




                                                                                    4
             DFS starting from A:                     Modification of depth first search
                                                      • How to get DFS to detect cycles in a directed graph:
                                      S={A,B,C,E,F}
                                                      idea: if we encounter a vertex which is already on the stack,
                                      S={A,B,C,E}        we found a loop (stack contains vertices on a path, and if
                                  D
              B           C           S={A,B,C}          we see the same vertex again, the path must contain a
                                      S={A,B}            cycle).
                                                      • Instead of visited and unvisited, use three colours:
     A                                S={A}
                      F       E                          – white = unvisited
                                      S={}               – grey = on the stack
                                                         – black = finished (we backtracked from it, seen everywhere we can
                                                           reach from it)
              G




Modification of depth first search                       Tracing modified DFS from A
Modified DFS starting from v:                                                                                 S = {}
all vertices coloured white
                                                                          C
create a stack S
colour v grey and push v onto S                                   B
while S is non-empty                                    A
  peek at the top u of S                                                              E
                                                                           D
  if u has a grey neighbour, there is a
  cycle
  else if u has a white neighbour w,
  colour w grey and push it onto S
  else colour u black and pop S




  Tracing modified DFS from A                            Tracing modified DFS from A
                                         S = {}                                                               S = {}
                  C                      S=A                              C                                   S=A

         B                                                        B                                             B
 A                                                      A                                                     S=A
                          E                                                           E
                  D                                                        D




                                                                                                                              5
Tracing modified DFS from A                     Tracing modified DFS from A
                                S = {}                                                        S = {}
        C                       S=A                            C                              S=A

    B                             B                     B                                       B
A                               S=A            A                                              S=A
            E                     C                                      E                      C
        D                                                       D
                                  B                                                             B
                                S=A                                                           S=A

                                                                                                B
                                                                                     pop:     S=A




Tracing modified DFS from A                     Tracing modified DFS from A
                       push:      D                                                  push:      D
                                  B                                                             B
        C                       S=A                            C                              S=A
    B                                                   B
A                                              A                                                E
            E                                                            E                      D
        D                                                       D                               B
                                                                                              S=A




Tracing modified DFS from A                     Pseudocode for BFS and DFS
                       push:      D          • To compute complexity, I will be referring to an adjacency
                                  B            list implementation
        C                       S=A          • Assume that we have a method which returns the first
    B                                          unmarked vertex adjacent to a given one:
A                                 E            GraphNode firstUnmarkedAdj(GraphNode v)
            E                     D                                         list of v’s neighbours
        D                         B
                                S=A
                E has a grey neighbour: B!
                Found a loop!                       v         u1(marked)      u2(unmarked) u3(unmarked)
                                                                                     bookmark




                                                                                                            6
              Implementation of                                          Pseudocode for breadth-first
             firstUnmarkedAdj()                                          search starting from vertex s
• We keep a pointer into the adjacency list of each vertex so      s.marked = true; // marked is a field in
  that we do not start to traverse the list of adjacent vertices                    // GraphNode
  from the beginning each time.                                    Queue Q = new Queue();
                                                                   Q.enqueue(s);
                                                                   while(! Q.isempty()) {
                                                                      v = Q.dequeue();
                                                                      u = firstUnmarkedAdj(v);
  v           u1(marked)      u2(unmarked)      u3(unmarked)          while (u != null){
                                                                         u.marked = true;
            currUnmarkedAdj
                                                                         Q.enqueue(u);
                                                                         u = firstUnmarkedAdj(v);}}}




                                                                      Space Complexity of BFS and
            Pseudocode for DFS                                                  DFS
s.marked = true;                                                   • Need a queue/stack of size |V| (the number of vertices).
Stack S = new Stack();                                               Space complexity O(V).
S.push(s);
while(! S.isempty()){
   v = S.peek();
   u = firstUnmarkedAdj(v);
   if (u == null) S.pop();
   else {
      u.marked = true;
      S.push(u);
   }
}




      Time Complexity of BFS and
                DFS                                                        Time complexity of BFS
• In terms of the number of vertices V: two nested loops                                           Adjacency lists:
  over V, hence O(V2).                                                                             V      E
                                                                                 v1
• More useful complexity estimate is in terms of the number                                        v0: {v1,v2}
  of edges. Usually, the number of edges is less than V2.                                          v1: {v3}
                                                                    v0                     v3
                                                                                                   v2: {v3}
                                                                                                   v3: {}

                                                                                v2




                                                                                                                                7
     Time complexity of BFS                           Time complexity of BFS
                  Adjacency lists:                                 Adjacency lists:
                  V      E                                         V      E
       v1                                               v1
                  v0: {v1,v2} mark, enqueue                        v0: {v1,v2} dequeue v0;
                    v0                                               mark, enqueue v1,v2
v0           v3                                  v0           v3
                  v1: {v3}                                         v1: {v3}
                  v2: {v3}                                         v2: {v3}
                  v3: {}                                           v3: {}
       v2                                               v2




     Time complexity of BFS                           Time complexity of BFS
                  Adjacency lists:                                 Adjacency lists:
                  V      E                                         V      E
       v1                                               v1
                  v0: {v1,v2}                                      v0: {v1,v2}
                  v1: {v3} dequeue v1; mark,                       v1: {v3}
v0           v3                                  v0           v3
                    enqueue v3                                     v2: {v3} dequeue v2, check
                  v2: {v3}                                           its adjacency list (v3
                  v3: {}                                             already marked)
       v2                                               v2         v3: {}




     Time complexity of BFS                           Time complexity of BFS
                  Adjacency lists:                                 Adjacency lists:
                  V      E                                         V       E
       v1                                               v1
                  v0: {v1,v2}                                      v0: {v1,v2} |E0| = 2
                  v1: {v3}                                         v1: {v3} |E1| = 1
v0           v3                                  v0           v3
                  v2: {v3}                                         v2: {v3} |E2| = 1
                  v3: {} dequeue v3; check its                     v3: {} |E3| = 0
                    adjacency list                                 Total number of steps:
       v2                                               v2         |V| + |E0| + |E1| + |E2| +|E3|
                                                                      =
                                                                   = |V|+|E|.




                                                                                                    8
     Complexity of breadth-first
              search                                             Complexity of depth-first search
• Assume an adjacency list representation, V is the number      • Each vertex is pushed on the stack and popped at most
  of vertices, E the number of edges.                             once.
• Each vertex is enqueued and dequeued at most once.
                                                                • For every vertex we check what the next unvisited
• Scanning for all adjacent vertices takes O(|E|) time, since     neighbour is.
  sum of lengths of adjacency lists is |E|.
• Gives a O(|V|+|E|) time complexity.                           • In our implementation, we traverse the adjacency list only
                                                                  once. This gives O(|V|+|E|) again.




                                                                                                                               9

								
To top