Two standard graph traversal techniques in data structures.

1. Reference: Data Structures and Algorithm
Analysis in C++ by Weiss Ch. 9
Prepared by Nisha Soms
Graph Traversals

2. 2
Graphs
2
 graph: A data structure containing:
 a set of vertices V, (sometimes called nodes)
 a set of edges E, where an edge
represents a connection between 2 vertices.
 Graph G = (V, E)
 an edge is a pair (v, w) where v, w are in V
 the graph at right:
 V = {a, b, c, d}
 E = {(a, c), (b, c), (b, d), (c, d)}
 degree: number of edges touching a given vertex.
 at right: a=1, b=2, c=3, d=2
a
c
b
d

3. 3
Graph examples
3
 Web pages with links
 Methods in a program that call each other
 Road maps (e.g., Google maps)
 Airline routes
 Facebook friends
 Course pre-requisites
 Family trees
 Paths through a maze

4. 4
Paths
4
 path: A path from vertex a to b is a sequence of edges that
can be followed starting from a to reach b.
 can be represented as vertices visited, or edges taken
 example, one path from V to Z: {b, h} or {V, X, Z}
 What are two paths from U to Y?
 path length: Number of vertices
or edges contained in the path.
 neighbor or adjacent: Two vertices
connected directly by an edge.
 example: V and X
X
U
V
W
Z
Y
a
c
b
e
d
f
g
h

5. 5
Reachability & Connectedness
5
 reachable: Vertex a is reachable from b
if a path exists from a to b.
 connected: A graph is connected if every
vertex is reachable from any other.
 strongly connected: When every vertex
has an edge to every other vertex.
X
U
V
W
Z
Y
a
c
b
e
d
f
g
h
a
c
b
d
a
c
b
d
e

6. 6
Loops and cycles
6
 cycle: A path that begins and ends at the same node.
 example: {b, g, f, c, a} or {V, X, Y, W, U, V}.
 example: {c, d, a} or {U, W, V, U}.
 acyclic graph: One that does
not contain any cycles.
 loop: An edge directly from
a node to itself.
 Many graphs don't allow loops.
X
U
V
W
Z
Y
a
c
b
e
d
f
g
h

7. 7
Weighted graphs
7
 weight: Cost associated with a given edge.
 Some graphs have weighted edges, and some are
unweighted.
 Edges in an unweighted graph can be thought of as having
equal weight (e.g. all 0, or all 1, etc.)
 Most graphs do not allow negative weights.
 example: graph of airline flights, weighted by miles
between cities:
ORD
PVD
MIA
DFW
SFO
LAX
LGA
HNL

8. 8
Directed graphs
8
 directed graph ("digraph"): One where edges are one-way
connections between vertices.
 If graph is directed, a vertex has a separate in/out degree.
 A digraph can be weighted or unweighted.
 Is the graph below connected? Why or why not?
a
d
b
e
g
f
c

9. 9
Linked Lists, Trees, Graphs
9
 A binary tree is a graph with some restrictions:
 The tree is an unweighted, directed, acyclic graph (DAG).
 Each node's in-degree is at most 1, and out-degree is at most
2.
 There is exactly one path from the root to every node.
 A linked list is also a graph:
 Unweighted DAG.
 In/out degree of at most 1 for all nodes.
F
B
A E
K
H
J
G
A B D
C

10. 10
Searching for paths
10
 Searching for a path from one vertex to another:
 Sometimes, we just want any path (or want to know there is a
path).
 Sometimes, we want to minimize path length (# of edges).
 Sometimes, we want to minimize path cost (sum of edge
weights).
 What is the shortest path from MIA to SFO?
Which path has the minimum cost?
ORD
PVD
MIA
DFW
SFO
LAX
LGA
HNL
$500

11. 11
Depth-first search
11
 Depth-first search (DFS): Finds a path between two
vertices by exploring each possible path as far as possible
before backtracking.
 Often implemented recursively.
 Many graph algorithms involve visiting or marking vertices.
 Depth-first paths from a to all vertices (assuming ABC edge
order):
 to b: {a, b}
 to c: {a, b, e, f, c}
 to d: {a, d}
 to e: {a, b, e}
 to f: {a, b, e, f}
a
e
b c
h
g
d f

12. 12
DFS pseudocode
12
function dfs(v1, v2):
dfs(v1, v2, { }).
function dfs(v1, v2, path):
path += v1.
mark v1 as visited.
if v1 is v2:
a path is found!
for each unvisited neighbor n of v1:
if dfs(n, v2, path) finds a path: a path is found!
path -= v1. // path is not found.
a
e
b c
h
g
d f

13. 13
DFS observations
13
 discovery: DFS is guaranteed to
find a path if one exists.
 retrieval: It is easy to retrieve exactly
what the path is (the sequence of
edges taken) if we find it
 optimality: not optimal. DFS is guaranteed to find a path,
not necessarily the best/shortest path
 Example: dfs(a, f) returns {a, d, c, f} rather than {a, d, f}.
a
e
b c
h
g
d f

14. 14
Breadth-first search
14
 Breadth-first search (BFS): Finds a path between two
nodes by taking one step down all paths and then
immediately backtracking.
 Often implemented by maintaining a queue of vertices to visit.
 BFS always returns the shortest path (the one with the
fewest edges) between the start and the end vertices.
 to b: {a, b}
 to c: {a, e, f, c}
 to d: {a, d}
 to e: {a, e}
 to f: {a, e, f}
 to g: {a, d, g}
 to h: {a, d, h}
a
e
b c
h
g
d f

15. 15
BFS pseudocode
15
function bfs(v1, v2):
queue := {v1}.
mark v1 as visited.
while queue is not empty:
v := queue.removeFirst().
if v is v2:
a path is found!
for each unvisited neighbor n of v:
mark n as visited.
queue.addLast(n).
// path is not found.
a
e
b c
h
g
d f

16. 16
BFS observations
16
 Optimality:
 always finds the shortest path (fewest edges).
 In unweighted graphs, finds optimal cost path.
 In weighted graphs, not always optimal cost.
 Retrieval: harder to reconstruct the actual sequence of
vertices or edges in the path once you find it
 conceptually, BFS is exploring many possible paths in parallel,
so it's not easy to store a path array/list in progress
 solution: We can keep track of the path by storing
predecessors for each vertex (each vertex can store a
reference to a previous vertex).
 DFS uses less memory than BFS, easier to reconstruct the
a
e
b c
h
g
d f

17. 17
DFS, BFS runtime
17
 What is the expected runtime of DFS and BFS, in terms of
the number of vertices V and the number of edges E ?
 Answer: O(|V| + |E|)
 where |V| = number of vertices, |E| = number of edges
 Must potentially visit every node and/or examine every edge
once.

18. 18
BFS that finds path
18
function bfs(v1, v2):
queue := {v1}.
mark v1 as visited.
while queue is not empty:
v := queue.removeFirst().
if v is v2:
a path is found! (reconstruct it by following .prev back
to v1.)
for each unvisited neighbor n of v:
mark n as visited. (set n.prev = v.)
queue.addLast(n).
// path is not found.
a
e
b c
h
g
d f
prev

19. Thank you