COMP171

Depth-First Search
Graph / Slide 2

Summary of BFS

☛ Graph and representations

☛ BFS, and BFS tree
☛ Complexity of BFS
Graph / Slide 3
Two representations:
Adjacency List vs. Matrix
☛ Two sizes: n = |V| and m=|E|,
■ m = O(n^2)

☛ Adjacency List
■ More compact than adjacency matrices if graph has few edges

■ Requires a scan of adjacency list to check if an edge exists

■ Requires a scan to obtain all edges!

☛ Adjacency Matrix
■ Always require n2 space
This can waste a lot of space if the number of edges are sparse

■ find if an edge exists in O(1)

■ Obtain all edges in O(n)
Graph / Slide 4

BFS Tree
BFS tree for vertex s=2.
Graph / Slide 5

Time Complexity of BFS

(Using Adjacency List)

O(n + m)

Each vertex will enter Q

at most once.

Each iteration takes time

proportional to deg(v) + 1 (the
number 1 is to account for the
case where deg(v) = 0 --- the
work required is 1, not 0).
Graph / Slide 6

Time Complexity of BFS

(Using Adjacency Matrix)

O(n2)

Finding the adjacent vertices of v

requires checking all elements in the
row. This takes linear time O(n).

Summing over all the n iterations, the

total running time is O(n2).
So, with adjacency matrix, BFS is O(n2)
independent of the number of edges m.
With adjacent lists, BFS is O(n+m); if
m=O(n2) like in a dense graph,
O(n+m)=O(n2).
Graph / Slide 7

Depth-First Search (DFS)

☛ DFS is another popular graph search strategy
■ Idea is similar to pre-order traversal (visit node,
then visit children recursively)

☛ DFS can provide certain information about

the graph that BFS cannot
■ It can tell whether we have encountered a cycle or
not
Graph / Slide 8

DFS Algorithm
☛ DFS will continue to visit neighbors in a
recursive pattern
■ Whenever we visit v from u, we recursively visit all
unvisited neighbors of v. Then we backtrack
(return) to u.

■ Note: it is possible that w2 was unvisited when we

recursively visit w1, but became visited by the time
we return from the recursive call.
u

v w3
w1 w2
Graph / Slide 9

DFS Algorithm

Flag all vertices as not

visited

Flag yourself as visited

For unvisited neighbors,

call RDFS(w) recursively

We can also record the paths using pred[ ].

Graph / Slide 10

Example
Adjacency List Visited Table (T/F)
0 0 F -

8 1 F -

2 F -

source 2 9
3 F -

4 F -
1
5 F -

3 7 6 F -

6 7 F -
4
5 8 F -

9 F -

Pred
Initialize visited
table (all False)

Initialize Pred to -1
Graph / Slide 11

Adjacency List Visited Table (T/F)

0 0 F -

1 F -
8 2 T -

3 F -
source 2 9 4 F -

1 5 F -

6 F -
3 7
7 F -
6
4 8 F -
5 9 F -

Pred
Mark 2 as visited

RDFS( 2 )
Now visit RDFS(8)
Graph / Slide 12

Adjacency List Visited Table (T/F)

0
0 F -
8 1 F -

2 T -
source 2 9 3 F -

1 4 F -

5 F -

3 7 6 F -
6 7 F -
4
5 8 T 2

9 F -

Pred
Mark 8 as visited
Recursive RDFS( 2 )
calls RDFS(8) mark Pred[8]
2 is already visited, so visit RDFS(0)
Graph / Slide 13

Adjacency List Visited Table (T/F)

0
0 T 8
8 1 F -

2 T -
source 2 9 3 F -

1 4 F -

5 F -

3 7 6 F -
6 7 F -
4
5 8 T 2

9 F -

Pred
Mark 0 as visited
Recursive RDFS( 2 )
calls RDFS(8) Mark Pred[0]
RDFS(0) -> no unvisited neighbors, return
to call RDFS(8)
Graph / Slide 14

Back to 8
Adjacency List Visited Table (T/F)
0
0 T 8
8 1 F -

2 T -
source 2 9 3 F -

1 4 F -

5 F -

3 7 6 F -
6 7 F -
4
5 8 T 2

9 F -

Pred

Recursive RDFS( 2 )
calls RDFS(8)
Now visit 9 -> RDFS(9)
Graph / Slide 15

Adjacency List Visited Table (T/F)

0
0 T 8
8 1 F -

2 T -
source 2 9 3 F -

1 4 F -

5 F -

3 7 6 F -
6 7 F -
4
5 8 T 2

9 T 8

Pred
Mark 9 as visited
Recursive RDFS( 2 )
calls RDFS(8) Mark Pred[9]
RDFS(9)
-> visit 1, RDFS(1)
Graph / Slide 16

Adjacency List Visited Table (T/F)

0
0 T 8
8 1 T 9

2 T -
source 2 9 3 F -

1 4 F -

5 F -

3 7 6 F -
6 7 F -
4
5 8 T 2

9 T 8

Pred
Mark 1 as visited
Recursive RDFS( 2 )
calls RDFS(8) Mark Pred[1]
RDFS(9)
RDFS(1)
visit RDFS(3)
Graph / Slide 17

Adjacency List Visited Table (T/F)

0
0 T 8
8 1 T 9

2 T -
source 2 9 3 T 1

1 4 F -

5 F -

3 7 6 F -
6 7 F -
4
5 8 T 2

9 T 8

Pred
Mark 3 as visited
Recursive RDFS( 2 )
calls RDFS(8) Mark Pred[3]
RDFS(9)
RDFS(1)
RDFS(3)
visit RDFS(4)
Graph / Slide 18

Adjacency List Visited Table (T/F)

0
0 T 8
8 1 T 9

2 T -
source 2 9 3 T 1

1 4 T 3

5 F -

3 7 6 F -
6 7 F -
4
5 8 T 2

9 T 8

Pred
RDFS( 2 ) Mark 4 as visited
RDFS(8)
Recursive
calls RDFS(9) Mark Pred[4]
RDFS(1)
RDFS(3)
RDFS(4)  STOP all of 4’s neighbors have been visited
return back to call RDFS(3)
Graph / Slide 19

Adjacency List Visited Table (T/F)

0
0 T 8
8 1 T 9

2 T -
source 2 9 3 T 1

1 4 T 3

5 F -

3 7 6 F -
6 7 F -
4
5 8 T 2

9 T 8
Back to 3
Pred
RDFS( 2 )
RDFS(8)
Recursive
calls RDFS(9)
RDFS(1)
RDFS(3)
visit 5 -> RDFS(5)
Graph / Slide 20

Adjacency List Visited Table (T/F)

0
0 T 8
8 1 T 9

2 T -
source 2 9 3 T 1

1 4 T 3

5 T 3

3 7 6 F -
6 7 F -
4
5 8 T 2

9 T 8

Pred
RDFS( 2 )
RDFS(8) Mark 5 as visited
Recursive
calls RDFS(9)
RDFS(1) Mark Pred[5]
RDFS(3)
RDFS(5)
3 is already visited, so visit 6 -> RDFS(6)
Graph / Slide 21

Adjacency List Visited Table (T/F)

0
0 T 8
8 1 T 9

2 T -
source 2 9 3 T 1

1 4 T 3

5 T 3

3 7 6 T 5
6 7 F -
4
5 8 T 2

9 T 8

Pred
RDFS( 2 )
RDFS(8)
Recursive RDFS(9) Mark 6 as visited
calls RDFS(1) Mark Pred[6]
RDFS(3)
RDFS(5)
RDFS(6)
visit 7 -> RDFS(7)
Graph / Slide 22

Adjacency List Visited Table (T/F)

0
0 T 8
8 1 T 9

2 T -
source 2 9 3 T 1

1 4 T 3

5 T 3

3 7 6 T 5
6 7 T 6
4
5 8 T 2

9 T 8

Pred
RDFS( 2 )
RDFS(8)
Recursive RDFS(9) Mark 7 as visited
calls RDFS(1) Mark Pred[7]
RDFS(3)
RDFS(5)
RDFS(6)
RDFS(7) -> Stop no more unvisited neighbors
Graph / Slide 23

Adjacency List Visited Table (T/F)

0 0 T 8

1 T 9
8
2 T -

3 T 1
source 2 9 4 T 3
1 5 T 3

3 7 6 T 5

6 7 T 6

4 8 T 2
5
9 T 8

Pred
RDFS( 2 )
RDFS(8)
Recursive RDFS(9)
calls RDFS(1)
RDFS(3)
RDFS(5)
RDFS(6) -> Stop
Graph / Slide 24

Adjacency List Visited Table (T/F)

0 0 T 8

1 T 9
8
2 T -

3 T 1
source 2 9 4 T 3
1 5 T 3

3 7 6 T 5

6 7 T 6

4 8 T 2
5
9 T 8

Pred
RDFS( 2 )
RDFS(8)
Recursive RDFS(9)
calls RDFS(1)
RDFS(3)
RDFS(5) -> Stop
Graph / Slide 25

Adjacency List Visited Table (T/F)

0 0 T 8

1 T 9
8
2 T -

3 T 1
source 2 9 4 T 3
1 5 T 3

3 7 6 T 5

6 7 T 6

4 8 T 2
5
9 T 8

Pred
RDFS( 2 )
RDFS(8)
Recursive RDFS(9)
calls RDFS(1)
RDFS(3) -> Stop
Graph / Slide 26

Adjacency List Visited Table (T/F)

0 0 T 8

1 T 9
8
2 T -

3 T 1
source 2 9 4 T 3
1 5 T 3

3 7 6 T 5

6 7 T 6

4 8 T 2
5
9 T 8

Pred
RDFS( 2 )
RDFS(8)
Recursive RDFS(9)
calls RDFS(1) -> Stop
Graph / Slide 27

Adjacency List Visited Table (T/F)

0 0 T 8

1 T 9
8
2 T -

3 T 1
source 2 9 4 T 3
1 5 T 3

3 7 6 T 5

6 7 T 6

4 8 T 2
5
9 T 8

Pred
RDFS( 2 )
RDFS(8)
Recursive RDFS(9) -> Stop
calls
Graph / Slide 28

Adjacency List Visited Table (T/F)

0 0 T 8

1 T 9
8
2 T -

3 T 1
source 2 9 4 T 3
1 5 T 3

3 7 6 T 5

6 7 T 6

4 8 T 2
5
9 T 8

Pred
RDFS( 2 )
RDFS(8) -> Stop
Recursive
calls
Graph / Slide 29

Example Finished
Adjacency List Visited Table (T/F)
0 0 T 8

1 T 9
8
2 T -

3 T 1
source 2 9 4 T 3
1 5 T 3

3 7 6 T 5

6 7 T 6

4 8 T 2
5
9 T 8

Pred
RDFS( 2 ) -> Stop

Recursive calls finished

Graph / Slide 30

DFS Path Tracking

0 Adjacency List Visited Table (T/F)
8 0 T 8

1 T 9

source 2 9
2 T -

3 T 1
1
4 T 3

3 7 5 T 3

6 6 T 5
4
5 7 T 6

8 T 2

9 T 8

DFS find out path too Pred

Try some examples.

Path(0) ->
Path(6) ->
Path(7) ->
Graph / Slide 31

DFS Tree
Resulting DFS-tree.
Notice it is much “deeper”
than the BFS tree.

Captures the structure of the

recursive calls
- when we visit a neighbor w of v,
we add w as child of v
- whenever DFS returns from a
vertex v, we climb up in the tree
from v to its parent
Graph / Slide 32

Time Complexity of DFS

(Using adjacency list)
☛ We never visited a vertex more than once

☛ We had to examine all edges of the vertices

■ We know Σvertex v degree(v) = 2m where m is the number of
edges

☛ So, the running time of DFS is proportional to the

number of edges and number of vertices (same as BFS)
■ O(n + m)

☛ You will also see this written as:

■ O(|v|+|e|) |v| = number of vertices (n)
|e| = number of edges (m)