Graphs Definition of a graph

Plan of the lecture: A graph is a set of nodes, or vertices, connected by edges.

• What is a graph
D
B C
• What are they used for

• Graph problems
A E
• Two ways of implementing graphs F
• BFS and DFS, their complexity

Applications of Graphs Directed and Undirected Graphs

Graphs can be used to represent Graphs can be

• networks (e.g., of computers or roads) • undirected (edges don’t have direction)

• flow charts • directed (edges have direction)

• tasks in some project (some of which should be completed B

before others), so edges correspond to prerequisites.
D directed graph
A
• states of an automaton / program

Weighted and Unweighted

Directed and Undirected Graphs
Graphs
Undirected graphs can be represented as directed graphs Graphs can also be
where for each edge (X,Y) there is a corresponding edge
(Y,X). • unweighted (as in the previous examples)

• weighted (edges have weights)

A B C undirected graph B
10 12
A B C corresponding D
A weighted graph
directed graph 8
14
C

1
 Notation Adjacency relation
• Set V of vertices (nodes) • Node B is adjacent to A if there is an edge from A to B.
• Set E of edges (E ⊆ V × V)
A B
Example: B C

V = {A, B, C}, E = {(A,B), (A,C), (B,C)}

Paths and reachability More Terminology

• A cycle is a path from a vertex to itself
• A path from A to B is a sequence of vertices A1,...,An such • Graph is acyclic if it does not have cycles
that there is an edge from A to A1, from A1 to A2, ..., from
• Graph is connected if there is a path between every pair of
An to B.
vertices
• Graph is strongly connected if there is a path in both
directions between every pair of vertices
A A1 A2 A3 A4 A5 B

• A vertex B is reachable from A if there is a path from A to

B

Applications of Graphs Some graph problems

For example, • Searching a graph for a vertex
• nodes could represent positions in a board game, and edges • Searching a graph for an edge
the moves that transform one position into another ...
• nodes could represent computers (or routers) in a network • Finding a path in the graph (from one vertex to another)
and weighted edges the bandwidth between them • Finding the shortest path between two vertices
• nodes could represent towns and weighted edges road
distances between them, or train journey times or ticket • Cycle detection
prices ...

2
 More graph problems How to implement a graph
• Topological sort (finding a linear sequence of vertices As with lists, there are several approaches, e.g.:
which agrees with the direction of edges in the graph, e.g.,
for scheduling tasks in a project) • using a static indexed data structure

• Minimal spanning tree (deleting as many edges in a graph • using a dynamic data structure
as possible, so that all vertices are still connected by
shortest possible edges, e.g., in network routing or circuit
design.)

Static implementation:Adjacency
Example
Matrix
• Store node in the array: each node is associated with an B 0 1 2 3
integer (array index)
0 0 1 1 0
• Represent information about the edges using a two
dimensional array, where A D 1 0 0 0 1
2 0 0 0 1
array[i][j] == 1
3 0 0 0 0
iff there is an edge from node with index i to the node C
with index j. A B C D node indices adjacency
0 1 2 3 matrix

Weighted graphs Finding node’s index fast

• For weighted graphs, place weights in matrix (if there is no • Keeping node labels in an array is a bit awkward (have to
edge we use a value which can’t be confused with a look through the array each time to find node’s position in
weight, e.g., -1 or Integer.MAX_VALUE) the matrix)

• Alternative solution would be to use a HashMap: the node

is the key, and an Integer object holding its index is the
value.

• When we need to know the node v’s position we could do

int pos = map.get(v);

3
 Disadvantages of adjacency
Adjacency List
matrices
• Sparse graphs with few edges for number of vertices result • For every vertex, keep a list of adjacent vertices.
in many zero entries in adjacency matrix—this wastes • Keep a list of vertices, or keep vertices in a HashMap as
space and makes many algorithms less efficient (e.g., to keys and lists of adjacent vertices as values.
find nodes adjacent to a given node, we have to iterate
through the whole row even if there are few 1s there).

• Also, if the number of nodes in the graph may change,

matrix representation is too inflexible (especially if we
don’t know the maximal size of the graph).

Adjacency list HashMap implementation

B nodes list of adjacent nodes
Key Value
A B, C

A D B D A Linked list containing B,C

B Linked list containing D
C D
C Linked list containing D
C D
D Empty linked list

Reading Graph traversals

• Goodrich and Tamassia (Ch. 13) have a somewhat • In this lecture, we look at two ways of visiting all vertices
different Graph implementation, where edges are in a graph: breadth-first search and depth-first search.
first-class objects. • Traversal of the graph is used to perform tasks such as
searching for a certain node
• In general, choice of implementation depends on • It can also be slightly modified to search for a path
what we want to do with a graph. between two nodes, check if the graph is connected, check
if it contains loops, and so on.

4
 Breadth first search BFS starting from A:

BFS starting from vertex v:

Q={A}
Q={B,G}
D
create a queue Q B C Q={G,C,F}
mark v as visited and put v into Q
Q={C,F}
while Q is non-empty
remove the head u of Q A Q={F,D,E}
E
F
mark and enqueue all (unvisited) Q={D,E}
neighbours of u Q={E}
G Q={}

Simple DFS DFS starting from A:

DFS starting from vertex v: S={A}

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

DFS starting from A (continued): 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}
E – white = unvisited
F
S={}
– grey = on the stack
– black = finished (we backtracked from it, seen
G everywhere we can reach from it)

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

Tracing modified DFS from A

Pseudocode for BFS and DFS
(continued)
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

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();
• Or we use the same iterator for this list, so when we call Q.enqueue(s);
next() it returns the next element in the list – again does while(! Q.isempty()) {
not start from the beginning. 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);}}}

6
 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

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

7
 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|.

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.