52.219 Depth First Search (dfs)
Just as we had the traversals for trees (pre/in/post-order) we have
traversals for graphs. The first such traversal is called depth first
search (dfs), and may be considered as a "skeleton" for a number of
important algorithms (some of which we will visit)
Depth First Search is described informally as follows:
We have a directed graph G = (A,V) and we assume that all
vertices have an attribute called (mark v), where (mark v) is set to
"unvisited" for all vertices v in (V G).
Select some vertex of (V G), call it s, as a starting vertex and mark
vertex s as visited.
Each vertex w adjacent to s that has (mark w) equal to "unvisited" is
then searched in turn using depth first search recursively.
Once all vertices that can be reached from s have been visited the
search from s is complete
A scheme implementation of dfs is given in
and contains 2 implementations of dfs, one recursive the other
iterative. There is a wee demo function. The recursive implementation
is reproduced below.
(define (recursive-dfs s G)
(let ((mark (make-vector (+ 1 (n G)) #f)) ;(1)
(visited '())) ;(2)
(define (dfs' w) ;(3)
(cond ((not (vector-ref mark w)) ;(4)
(vector-set! mark w #t) ;(5)
(set! visited (cons w visited)) ;(6)
(do ((unvisited (adjacent-to w G) (cdr unvisited))) ;(7)
((null? unvisited)) ;(8)
(dfs' (first unvisited)))))) ;(9)
(dfs' s) ;(10)
;;; Depth first search from starting vertex s in graph G
;;; (1) Vector element (vector-ref mark w) is #t if vertex w has been visited
;;; otherwise (vector-ref mark w) is #f
;;; (2) visited is a list of vertices, giving the vertices in reverse
;;; order as visited by a dfs from vertex s in G
;;; (3) Local recursive function dfs' ... this is for cosmetics
;;; saving us having to pass in the vector mark every call
;;; (4) If we have not already visited the vertex w ...
;;; (5) ... then set w's mark ast true ...
;;; (6) ... push w onto the set of visited vertices ...
;;; (7-9) ... then make recursive calls to dfs' from the vertices
;;; adjacent to w in G
Complexity of dfs
In the above implementation, on each recursive call to (dfs' w)
if the vertex w has not already been visited (line 4) then
the vertex w is marked as having been visited (line 5), w is then pushed
on to the list of visited vertices (line 6) and we then do a depth
first search, in turn, off each of the vertices adjacent to w in G
(lines 7 to 9). If vertex w has been visited (ie. line 4 fails) then
nothing happens. If vertex w has not been visited we then get all the
vertices adjacent to w in G, and this operation takes time of order O(n).
At most we can visit each of the n vertices of G once only.
Consequently we perform the operation of line 7 (getting the adjacent
vertices) at most n times. Therefore, the overall complexity is at
worst O(n*n). In fact the complexity is of the order O(a') where a'
is the number of directed arcs in G (and that is O(p.n.n) where p is
the probability of an arc existing between 2 vertices).