Graphs

What is a graph?
• Graphs represent the relationships among data items
• A graph G consists of
• a set V of nodes (vertices)
• a set E of edges: each edge connects two nodes
• Each node represents an item
• Each edge represents the relationship between two
items

node

edge
Examples of graphs
Molecular Structure Computer Network
H Server 1 Terminal 1

H C H
Terminal 2
H Server 2

Other examples: electrical and communication networks,

airline routes, flow chart, graphs for planning projects
Formal Definition of graph
• The set of nodes is denoted as V
• For any nodes u and v, if u and v are connected by
an edge, such edge is denoted as (u, v)
v
(u, v)

• The set of edges is denoted as E u

• A graph G is defined as a pair (V, E)
Adjacent
• Two nodes u and v are said to be adjacent if (u, v)  E

v
(u, v)
u
w
u and v are adjacent
v and w are not adjacent
Path and simple path
• A path from v1 to vk is a sequence of nodes v1, v2, …,
vk that are connected by edges (v1, v2), (v2, v3), …, (vk-1,
v k)
• A path is called a simple path if every node appears at
most once.

v2 v3
v1

- v2, v3, v4, v2, v1 is a path

- v2, v3, v4, v5 is a path, also v4 v5
it is a simple path
Cycle and simple cycle
• A cycle is a path that begins and ends at the same
node
• A simple cycle is a cycle if every node appears at most
once, except for the first and the last nodes

v2
v1 v3
- v2, v3, v4, v5 , v3, v2 is a cycle
- v2, v3, v4, v2 is a cycle, it is v5
also a simple cycle
v4
Connected graph
• A graph G is connected if there exists path between every pair of
distinct nodes; otherwise, it is disconnected

v2
v1 v3

v4 v5
This is a connected graph because there exists path
between every pair of nodes
Example of disconnected graph

v1 v3 v7 v8
v2
v4 v5
v6 v9
This is a disconnected graph because there does not
exist path between some pair of nodes, says, v1 and v7
Connected component
• If a graph is disconnect, it can be partitioned into a
number of graphs such that each of them is
connected. Each such graph is called a connected
component.

v2 v7 v8
v1 v3

v4 v5
v6 v9
Complete graph
• A graph is complete if each pair of distinct nodes has an edge

Complete graph Complete graph

with 3 nodes with 4 nodes
Subgraph
• A subgraph of a graph G =(V, E) is a graph H = (U, F)
such that U  V and
F  E.

v2 v2
v1 v3 v3

v4 v5 v4 v5

G H
Weighted graph
• If each edge in G is assigned a weight, it is called a
weighted graph

Chicago New York

1000

3500
2000

Houston
Directed graph (digraph)
• All previous graphs are undirected graph
• If each edge in E has a direction, it is called a directed edge
• A directed graph is a graph where every edges is a directed
edge

Chicago New York

1000

Directed edge
2000
3500

Houston
More on directed graph
x y

• If (x, y) is a directed edge, we say

• y is adjacent to x
• y is successor of x
• x is predecessor of y
• In a directed graph, directed path, directed cycle can
be defined similarly
Multigraph
• A graph cannot have duplicate edges.
• Multigraph allows multiple edges and self edge (or loop).

Self edge Multiple edge

Property of graph
• A undirected graph that is connected and has no cycle
is a tree.
• A tree with n nodes have exactly n-1 edges.
• A connected undirected graph with n nodes must
have at least n-1 edges.
Implementing Graph
• Adjacency matrix
• Represent a graph using a two-dimensional array
• Adjacency list
• Represent a graph using n linked lists where n is the number of vertices
Adjacency matrix for directed graph

Matrix[i][j] = 1 if (vi, vj)E 1 2 3 4 5

0 if (vi, vj)E
v1 v2 v3 v4 v5

v2 1 v1 0 1 0 0 0
v1 v3 2 v 0 0 0 1 0
2

3 v3 0 1 0 1 0
v4 v5 4 v4 0 0 0 0 0
5 v5 0 0 1 1 0
G
Adjacency matrix for weighted undirected graph
Matrix[i][j] = w(vi, vj) if (vi, vj)E or (vj, vi)E
∞ otherwise
1 2 3 4 5
v2 v1 v2 v3 v4 v5
v1 2 v3
5 1 v1 ∞ 5 ∞ ∞ ∞
4 3 7 2 v2 5 ∞ 2 4 ∞
v4
8 v5 3 v3 0 2 ∞ 3 7
4 v4 ∞ 4 3 ∞ 8
G
5 v5 ∞ ∞ 7 8 ∞
Adjacency list for directed graph

1 v1  v2
v2 2 v2  v4
v1 v3
3 v3  v2  v4
4 v4
v4 v5
5 v5  v3  v4
G
Adjacency list for weighted undirected graph

v2
v1 2 v3 1 v1  v2(5)
5
4 2 v2  v1(5)  v3(2)  v4(4)
3 7
3 v3  v2(2)  v4(3)  v5(7)
v4
8 v5 4 v4  v2(4)  v3(3)  v5(8)
5 v5  v3(7)  v4(8)
G
Pros and Cons
• Adjacency matrix
• Allows us to determine whether there is an edge from node i to node j in O(1)
time
• Adjacency list
• Allows us to find all nodes adjacent to a given node j efficiently
• If the graph is sparse, adjacency list requires less space
Problems related to Graph
• Graph Traversal
• Topological Sort
• Spanning Tree
• Minimum Spanning Tree
• Shortest Path
Graph Traversal Algorithm
• To traverse a tree, we use tree traversal algorithms like pre-order, in-
order, and post-order to visit all the nodes in a tree
• Similarly, graph traversal algorithm tries to visit all the nodes it can
reach.
• If a graph is disconnected, a graph traversal that begins at a node v
will visit only a subset of nodes, that is, the connected component
containing v.
Two basic traversal algorithms
• Two basic graph traversal algorithms:
• Depth-first-search (DFS)
• After visit node v, DFS strategy proceeds along a path from v as deeply into the graph as
possible before backing up
• Breadth-first-search (BFS)
• After visit node v, BFS strategy visits every node adjacent to v before visiting any other
nodes
Depth-first search (DFS)
• DFS strategy looks similar to pre-order. From a given node v, it
first visits itself. Then, recursively visit its unvisited neighbours
one by one.
• DFS can be defined recursively as follows.

Algorithm dfs(v)
print v; // you can do other things!
mark v as visited;
for (each unvisited node u adjacent to v)
dfs(u);
DFS example
• Start from v3
1
v3
2
v2 v2
v1 v3
x x x 3 4
v1 v4
v4
x x v5
5
G v5

2021/6/21 CS201 28
Non-recursive version of DFS algorithm
Algorithm dfs(v)
s.createStack();
s.push(v);
mark v as visited;
while (!s.isEmpty()) {
let x be the node on the top of the stack s;
if (no unvisited nodes are adjacent to x)
s.pop(); // blacktrack
else {
select an unvisited node u adjacent to x;
s.push(u);
mark u as visited;
}
}

2021/6/21 CS201 29
Non-recursive DFS example
visit stack
v3 v3
v2
v2 v3 , v 2
v1 v3
v1 v3 , v 2 , v 1
x x x
backtrack v3 , v 2
v4 v3 , v 2 , v 4
v4
x x v5
v5 v3 , v 2 , v 4 , v 5
backtrack v3 , v 2 , v 4
backtrack v3 , v 2
backtrack v3
G
backtrack empty
Breadth-first search (BFS)
• BFS strategy looks similar to level-order. From a given node v, it first
visits itself. Then, it visits every node adjacent to v before visiting any
other nodes.
• 1. Visit v
• 2. Visit all v’s neigbours
• 3. Visit all v’s neighbours’ neighbours
• …
• Similar to level-order, BFS is based on a queue.
Algorithm for BFS
Algorithm bfs(v)
q.createQueue();
q.enqueue(v);
mark v as visited;
while(!q.isEmpty()) {
w = q.dequeue();
for (each unvisited node u adjacent to w) {
q.enqueue(u);
mark u as visited;
}
}
BFS example
• Start from v5 Visit Queue
(front to
1 back)
v5 v5 v5

v2 v3
empty
v1
x x
2 3 v3 v3
v3
x v4 v4 v3 , v 4

v4x
v4

x
4
v2 v2 v4 , v 2
v5 v2
G 5
empty

v1 v1 v1
empty
Topological order
• Consider the prerequisite structure for courses:

b d
a

c
e
• Each node x represents a course x
• (x, y) represents that course x is a prerequisite to course y
• Note that this graph should be a directed graph without cycles (called a
directed acyclic graph).
• A linear order to take all 5 courses while satisfying all prerequisites is called a
topological order.
• E.g.
• a, c, b, e, d
• c, a, b, e, d
Topological sort
• Arranging all nodes in the graph in a topological order

Algorithm topSort
n = |V|;
for i = 1 to n {
select a node v that has no successor;
aList.add(1, v);
delete node v and its edges from the graph;
}
return aList;
Example
b d b
a a

c c
e e
1. d has no 2. Both b and e have no
successor! successor! Choose e!
Choose d!
b b
a a
a
c
3. Both b and c have 4. Only b has no 5. Choose a!
no successor! successor! The topological order
Choose c! Choose b! is a,b,c,e,d
Topological sort algorithm 2
• This algorithm is based on DFS
Algorithm topSort2
s.createStack();
for (all nodes v in the graph) {
if (v has no predecessors) {
s.push(v);
mark v as visited;
}
}
while (!s.isEmpty()) {
let x be the node on the top of the stack s;
if (no unvisited nodes are adjacent to x) { // i.e. x has no unvisited successor
aList.add(1, x);
s.pop(); // blacktrack
} else {
select an unvisited node u adjacent to x;
s.push(u);
mark u as visited;
}
}
return aList;
Spanning Tree
• Given a connected undirected graph G, a spanning
tree of G is a subgraph of G that contains all of G’s
nodes and enough of its edges to form a tree.

v2
v1 v3

v4 v5
Spanning
tree Spanning tree is not unique!
DFS spanning tree
• Generate the spanning tree edge during the DFS
traversal.

Algorithm dfsSpanningTree(v)
mark v as visited;
for (each unvisited node u adjacent to v) {
mark the edge from u to v;
dfsSpanningTree(u);
}

• Similar to DFS, the spanning tree edges can be generated

based on BFS traversal.
Example of generating spanning tree based
on DFS
stack
v3 v3
v2
v2 v3 , v 2
v1 v3
v1 v3 , v 2 , v 1
x x x
backtrack v3 , v 2
v4 v3 , v 2 , v 4
v4
x x v5
v5 v3 , v 2 , v 4 , v 5
backtrack v3 , v 2 , v 4
backtrack v3 , v 2
backtrack v3
G
backtrack empty
Minimum Spanning Tree
• Consider a connected undirected graph where
• Each node x represents a country x
• Each edge (x, y) has a number which measures the cost of
placing telephone line between country x and country y
• Problem: connecting all countries while minimizing
the total cost
• Solution: find a spanning tree with minimum total
weight, that is, minimum spanning tree
Formal definition of minimum spanning tree
• Given a connected undirected graph G.
• Let T be a spanning tree of G.
• cost(T) = eTweight(e)
• The minimum spanning tree is a spanning tree T which minimizes
cost(T)
v2
v1 2 v3
5 Minimum
4 3 spanning
7
tree
v4
8 v5
Prim’s algorithm (I)
v2 v2 v2
v1 v1 v1
5 2 v3 5 2 v3 5 2 v3
4 3 4 3 4 3
7 7 7
v4 8 v5 v4 8 v5 v4 8 v5
Start from v5, find the Find the minimum edge Find the minimum edge
minimum edge attach to v5 attach to v3 and v5 attach to v2, v3 and v5

v2 v2
v1 v1
2 v3 5 2 v3
5
4 3 4 3
7 7
8 v4 8 v5
v4 v5
Find the minimum edge
attach to v2, v3 , v4 and v5
Prim’s algorithm (II)
Algorithm PrimAlgorithm(v)
• Mark node v as visited and include it in the minimum spanning tree;
• while (there are unvisited nodes) {
• find the minimum edge (v, u) between a visited node v and an unvisited node
u;
• mark u as visited;
• add both v and (v, u) to the minimum spanning tree;
}
Shortest path
• Consider a weighted directed graph
• Each node x represents a city x
• Each edge (x, y) has a number which represent the cost of traveling from city x
to city y
• Problem: find the minimum cost to travel from city x to city y
• Solution: find the shortest path from x to y
Formal definition of shortest path
• Given a weighted directed graph G.
• Let P be a path of G from x to y.
• cost(P) = ePweight(e)
• The shortest path is a path P which minimizes cost(P)
v2
v1 2 v3
5
4 3 Shortest Path
4

v4
8 v5
Dijkstra’s algorithm
• Consider a graph G, each edge (u, v) has a weight w(u, v) > 0.
• Suppose we want to find the shortest path starting from v1 to any
node vi
• Let VS be a subset of nodes in G
• Let cost[vi] be the weight of the shortest path from v1 to vi that passes
through nodes in VS only.
Example for Dijkstra’s algorithm
v1 v2 2 v3
5
4 3 4

v4
8 v5
v VS cost[v1] cost[v2] cost[v3] cost[v4] cost[v5]
1 [v1] 0 5 ∞ ∞ ∞
Example for Dijkstra’s algorithm
v2
v1 2 v3
5
4 3 4

v4
8 v5
v VS cost[v1] cost[v2] cost[v3] cost[v4] cost[v5]
1 [v1] 0 5 ∞ ∞ ∞
2 v2 [v1, v2] 0 5 ∞ 9 ∞
Example for Dijkstra’s algorithm
v2
v1 2 v3
5
4 3 4

v4
8 v5
v VS cost[v1] cost[v2] cost[v3] cost[v4] cost[v5]
1 [v1] 0 5 ∞ ∞ ∞
2 v2 [v1, v2] 0 5 ∞ 9 ∞
3 v4 [v1, v2, v4] 0 5 12 9 17
Example for Dijkstra’s algorithm
v2
v1 2 v3
5
4 3 4

v4
8 v5
v VS cost[v1] cost[v2] cost[v3] cost[v4] cost[v5]
1 [v1] 0 5 ∞ ∞ ∞
2 v2 [v1, v2] 0 5 ∞ 9 ∞
3 v4 [v1, v2, v4] 0 5 12 9 17
4 v3 [v1, v2, v4, v3] 0 5 12 9 16
5 v5 [v1, v2, v4, v3, v5] 0 5 12 9 16
Dijkstra’s algorithm
Algorithm shortestPath()
n = number of nodes in the graph;
for i = 1 to n
cost[vi] = w(v1, vi);
VS = { v1 };
for step = 2 to n {
find the smallest cost[vi] s.t. vi is not in VS;
include vi to VS;
for (all nodes vj not in VS) {
if (cost[vj] > cost[vi] + w(vi, vj))
cost[vj] = cost[vi] + w(vi, vj);
}
}
Summary
• Graphs can be used to represent many real-life
problems.
• There are numerous important graph algorithms.
• We have studied some basic concepts and algorithms.
• Graph Traversal
• Topological Sort
• Spanning Tree
• Minimum Spanning Tree
• Shortest Path