Graphs
 Graph G(V,E): finite set V of nodes
(vertices) plus a finite set E of arcs (or
edges) between nodes
 V = {A, B, C, D, E, F, G}
 E = {AA, AB, AD, CD, DE, BF, EF, FG, EG }
B
A
F
C
D
E.G.M. Petrakis
G
E
Graphs
1
Terminology
 Two vertices are adjacent if they are
connected with an edge
 Adjacent or neighbor vertices
 Subgraph of G=(V,E): a graph G’=(V’,E’)
where V’, E’ are subsets of V, E
 |V|,|E|: number of nodes, edges of G
 Complete graph: contains all possible edges
 |E| in Θ(|V|2)
E.G.M. Petrakis
Graphs
2
Undirected Graphs
B
C
A
E
D
G
H
F
 The edges are not directed from one
vertex to another
E.G.M. Petrakis
Graphs
3
Directed Graphs
B
C
A
E
D
G
H
F
 The edges are directed from one
vertex to another
E.G.M. Petrakis
Graphs
4
A
B
D
A
C
E
B
C
D
F
G
E.G.M. Petrakis
Graphs
5
More Definitions
 Vertex degree: maximum number of
incoming or outgoing edges
 in-degree: number of incoming edges
 out-degree: number outgoing edges
 Relation R on A: R = {<x, y>| x, y ∊ N}
 x<y
 x mod y = odd
 Labeled graph: labels on vertices or edges
 Weighted graph: weights on edges
E.G.M. Petrakis
Graphs
6
relation
3
weighted
10
3
1
10
7
5
8
5
17
1
6
E.G.M. Petrakis
3
8
1
17
5
6
Graphs
7
Paths
There exist edges connecting two nodes
Length of path: number of edges
Weighted graphs: sum of weights on path
Cycle: path (of length 3 or more)
connecting a vertex with itself
 Cyclic graph: contains cycle
 Acyclic graph: does not contain cycle
 DAG: Directed Acyclic Graph




E.G.M. Petrakis
Graphs
8
Connected Graphs
0
4
1
2
6
3
5
7
 An undirected graph is connected if
there is a path between any two
vertices
 Connected components: maximally
connected subgraphs
E.G.M. Petrakis
Graphs
9
Operations on Graphs




join (a,b)
a
join (a,b,x)
a
remv[wt] (a,b,x)
a
adjacent (a,b)
a
b
b
a
b
a x
b
a
b
b
b
adjacent (a,b) = true
adjacent (a,c) = false
c
E.G.M. Petrakis
Graphs
10
Build a Graph
read(n);
read and create n nodes
label them from 1 .. n
// number of nodes
while not eof(..)
{
read(node1, node2, w12);
joinwt(node1, node2, w12);
}
any graph algorithm
E.G.M. Petrakis
Graphs
11
Representation of Directed Graphs
directed graph
0
0
2
0
1
2
3
4
4
1
3
0
1
1
3
2
4
3
2
4
1
E.G.M. Petrakis
1
2
1
1
3 4
1
1
1
1
adjacency matrix
4
adjacency list
Graphs
12
Representation of Undirected Graphs
undirected graph
0
0
2
0
1
2
3
4
4
1
3
0
1
4
1
0
3
2
3
4
3
1
2
4
0
1
E.G.M. Petrakis
1
1
1
2
1
1
1
1
1
3 4
1
1 1
1 1
adjacency matrix
4
2
Graphs
adjacency list
13
Matrix Implementation
 Simple but difficult to process edges,
unused space in matrix
 mark: 1D array marking vertices
 mark[i] = 1 if vertex i has been visited
 typedef int *Edge;
 matrix: the actual Graph implemented as an
1D array of size n2
 edge (i, j) is found at matrix[i*n + j]
 if edge exists matrix[i*n + j] = wt
 otherwise matrix[i*n + j] = NOEDGE
E.G.M. Petrakis
Graphs
14
Graph Interface
interface Graph {
public int n();
public int e();
public Edge first(int v);
public Edge next(Edge w);
public boolean isEdge(Edge w);
public boolean isEdge(int i, int j);
public int v1(Edge w);
public int v2(Edge w);
public void setEdge(int i, int j, int weight);
public void setEdge(Edge w, int weight);
public void delEdge(Edge w);
public void delEdge(int i, int j);
public int weight(int i, int j);
public int weight(Edge w);
public void setMark(int v, int val);
public int getMark(int v);
} // interface Graph
E.G.M. Petrakis
Graphs
// Graph class ADT
// Number of vertices
// Number of edges
// Get first edge for vertex
// Get next edge for a vertex
// True if this is an edge
// True if this is an edge
// Where edge came from
// Where edge goes to
// Set edge weight
// Set edge weight
// Delete edge w
// Delete edge (i, j)
// Return weight of edge
// Return weight of edge
// Set Mark for v
// Get Mark for v
15
Implementation: Edge Class
interface Edge {
public int v1();
public int v2();
} // interface Edge
// Interface for graph edges
// Return the vertex it comes from
// Return the vertex it goes to
// Edge class for Adjacency Matrix graph representation
class Edgem implements Edge {
private int vert1, vert2; // The vertex indices
public Edgem(int vt1, int vt2)
{ vert1 = vt1; vert2 = vt2; }
public int v1() { return vert1; }
public int v2() { return vert2; }
} // class Edgem
E.G.M. Petrakis
Graphs
16
Graph class: Adjacency Matrix
class Graphm implements Graph {
private int[][] matrix;
private int numEdge;
public int[] Mark;
public Graphm(int n) {
Mark = new int[n];
matrix = new int[n][n];
numEdge = 0;
}
// Graph: Adjacency matrix
// The edge matrix
// Number of edges
// The mark array
// Constructor
public int n() { return Mark.length; }
public int e() { return numEdge; }
E.G.M. Petrakis
Graphs
// Number of vertices
// Number of edges
17
Adjacency Matrix (cont.)
public Edge first(int v) {
// Get the first edge for a vertex
for (int i=0; i<Mark.length; i++)
if (matrix[v][i] != 0)
return new Edgem(v, i);
return null; // No edge for this vertex
}
public Edge next(Edge w) { // Get next edge for a vertex
if (w == null) return null;
for (int i=w.v2()+1; i<Mark.length; i++)
if (matrix[w.v1()][i] != 0)
return new Edgem(w.v1(), i);
return null; // No next edge;
}
E.G.M. Petrakis
Graphs
18
Adjacency Matrix (cont.)
public boolean isEdge(Edge w) {
// True if this is an edge
if (w == null) return false;
else return matrix[w.v1()][w.v2()] != 0;
}
public boolean isEdge(int i, int j)
{ return matrix[i][j] != 0; }
// True if this is an edge
public int v1(Edge w)
{ return w.v1(); }
// Where edge comes from
public int v2(Edge w)
{ return w.v2(); }
// Where edge goes to
E.G.M. Petrakis
Graphs
19
Adjacency Matrix (cont.)
// Set edge weight
public void setEdge(int i, int j, int wt) {
Assert.notFalse(wt!=0, "Cannot set weight to 0");
matrix[i][j] = wt;
numEdge++;
}
// Set edge weight
public void setEdge(Edge w, int weight) {
if (w != null)
setEdge(w.v1(), w.v2(), weight);
}
E.G.M. Petrakis
Graphs
20
Adjacency Matrix (cont.)
public void delEdge(Edge w) {
if (w != null)
if (matrix[w.v1()][w.v2()] != 0) {
matrix[w.v1()][w.v2()] = 0;
numEdge--;
}
}
// Delete edge w
public void delEdge(int i, int j) {
if (matrix[i][j] != 0) {
matrix[i][j] = 0;
numEdge--;
}
}
// Delete edge (i, j)
E.G.M. Petrakis
Graphs
21
Adjacency Matrix (cont.)
public int weight(int i, int j) {
// Return weight of edge
if (matrix[i][j] == 0) return Integer.MAX_VALUE;
else return matrix[i][j];
}
public int weight(Edge w) {
// Return weight of edge
Assert.notNull(w, "Can't take weight of null edge");
if (matrix[w.v1()][w.v2()] == 0) return Integer.MAX_VALUE;
else return matrix[w.v1()][w.v2()];
}
public void setMark(int v, int val) { Mark[v] = val; }
public int getMark(int v) { return Mark[v]; }
// Set Mark
// Get Mark
} // class Graphm
E.G.M. Petrakis
Graphs
22
Implementation: Edge Class
// Edge class for Adjacency List graph representation
class Edgel implements Edge {
private int vert1, vert2; // Indices of v1, v2
private Link itself; // Pointer to node in adj list
public Edgel(int vt1, int vt2, Link it) //Constructor
{ vert1 = vt1; vert2 = vt2; itself = it; }
public int v1() { return vert1; }
public int v2() { return vert2; }
Link theLink() { return itself; } // Access adj list
} // class Edgel
E.G.M. Petrakis
Graphs
23
Graph Class: Adjacency List
class Graphl implements Graph {
private GraphList[] vertex;
private int numEdge;
public int[] Mark;
public Graphl(int n) {
Mark = new int[n];
vertex = new GraphList[n];
for (int i=0; i<n; i++)
vertex[i] = new GraphList();
numEdge = 0;
}
E.G.M. Petrakis
Graphs
//
//
//
//
Graph: Adjacency list
The vertex list
Number of edges
The mark array
// Constructor
24
Adjacency List (cont.)
public int n() { return Mark.length; } // Number of vertices
public int e() { return numEdge; }
// Number of edges
public Edge first(int v) { // Get the first edge for a vertex
vertex[v].setFirst();
if (vertex[v].currValue() == null) return null;
return new Edgel(v, ((int[])vertex[v].currValue())[0],
vertex[v].currLink());
}
E.G.M. Petrakis
Graphs
25
Adjacency List (cont.)
public boolean isEdge(Edge e) { // True if this is an edge
if (e == null) return false;
vertex[e.v1()].setCurr(((Edgel)e).theLink());
if (!vertex[e.v1()].isInList()) return false;
return ((int[])vertex[e.v1()].currValue())[0]
== e.v2();
110,60
}
public boolean isEdge(int i, int j) { // True if this is an edge
GraphList temp = vertex[i];
for (temp.setFirst(); ((temp.currValue() != null) &&
(((int[])temp.currValue())[0] < j)); temp.next());
return (temp.currValue() != null) &&
(((int[])temp.currValue())[0] == j);
}
E.G.M. Petrakis
Graphs
26
Adjacency List (cont.)
public int v1(Edge e) { return e.v1(); } // Where edge comes from
public int v2(Edge e) { return e.v2(); } // Where edge goes to
public Edge next(Edge e) {
//
Get next edge for a vertex
110,60
vertex[e.v1()].setCurr(((Edgel)e).theLink());
vertex[e.v1()].next();
if (vertex[e.v1()].currValue() == null) return null;
return new Edgel(e.v1(), ((int[])vertex[e.v1()].currValue())[0],
vertex[e.v1()].currLink());
}
E.G.M. Petrakis
Graphs
27
Adjacency List (cont.)
public void setEdge(int i, int j, int weight) {// Set edge weight
Assert.notFalse(weight!=0, "Cannot set weight to 0");
int[] currEdge = { j, weight };
if (isEdge(i, j))
// Edge already exists in graph
vertex[i].setValue(currEdge);
else {
// Add new edge to graph
vertex[i].insert(currEdge);
numEdge++;
}
}
public void setEdge(Edge w, int weight) // Set edge weight
{ if (w != null) setEdge(w.v1(), w.v2(), weight); }
E.G.M. Petrakis
Graphs
28
Adjacency List (cont.)
public int weight(int i, int j) { // Return weight of edge
if (isEdge(i, j)) return ((int[])vertex[i].currValue())[1];
else return Integer.MAX_VALUE;
}
public int weight(Edge e) { // Return weight of edge
if (isEdge(e)) return ((int[])vertex[e.v1()].currValue())[1];
else return Integer.MAX_VALUE;
}
public void setMark(int v, int val) { Mark[v] = val; } // Set Mark
public int getMark(int v) { return Mark[v]; }
// Get Mark
} // class Graphl
E.G.M. Petrakis
Graphs
29
A Better Implementation
arcptr
info nextnode
ndptr
info: data
arcptr: pointer to an adjacent
node
nextnode: pointer to a graph
B
node
ndptr: pointer to adjacent node
nextarc: pointer to next edge
A
D
C
E.G.M. Petrakis
nextarc
E
Graphs
30
graph
A
n
i
l
Β
C
n
i
l
D
E
n
i
l
n
i
l
<D,B>
n
i
l
<C,E>
n
i
l
<A,B>
E.G.M. Petrakis
<A,C>
<A,D>
Graphs
<A,E>
31
Graph Traversal
 Trees
 preorder
 inorder
 postorder
 Graphs
 Depth First Search (DFS)
 Breadth First Search (BFS)
E.G.M. Petrakis
Graphs
32
Depth First Search (DFS)
 Starting from vertex v, initially all
vertices are “unvisited”

void DFS(v) {
Mark(v) = true;
for each vertex w adjacent to v
if (!Mark(w)) DFS(w)
}
E.G.M. Petrakis
Graphs
33
Complexity of DFS
 O(|V| + |E|): adjacency list
representation
 O(|V|2) in dense graphs
 O(|V|2): matrix representation
E.G.M. Petrakis
Graphs
34
v = v1
v1
v2
v4
v3
v5 v6
DFS :
V1V2V4V8V5V6V3V7
v7
v8
v1
v2
v3
v4
v5
v6
v7
v8
E.G.M. Petrakis
2
1
1
2
2
3
3
4
3
4
6
8
8
8
8
5
5
7
6
Graphs
7
35
Breadth-First Search (BFS)
v = v1
v1
v2
v4
v3
v5
v6
ΒFS :
V1V2V3V4V5V6V7V8
v7
v8
E.G.M. Petrakis
Graphs
36
BFS (cont.)
 Starting from vertex v, all nodes “unvisited”, visit
adjacent nodes (use a queue)
void DFS(v) {
visited(v) = true;
enqueue(v, Q);
while ( Q ≠ 0 ) {
x = dequeue(Q);
for each y adjacent x
do if ! Mark(y) {
Mark(y) = TRUE;
enqueue(y,Q);
}
}
}
E.G.M. Petrakis
Graphs
37
v1
v = v1
v2
v3
front
v1
front
rear
v2
v3
v3
rear
v4
v5
v5
rear
v6
v7
output(v3)
rear
v8
output(v4)
front
front
v4
v4 v5 v6 v7
output(v1)
v8
front
v5
v6
v7
front
v6
v7
v8
front
v6
v8
E.G.M. Petrakis
output(v2)
rear
output(v5)
output(v6)
output(v7)
Graphs
38
Complexity of BFS
 O(|V|+|E|) : adjacency list
representation
 d1 + d2 + ...+ dn = |E|
 di = degree (vi)
 O(|V|2) : adjacency matrix
representation
E.G.M. Petrakis
Graphs
39
DFS Algorithm
static void DFS (Graph G, int v) {
PreVisit(G, v);
// Take appropriate action
G.setMark(v, VISITED);
for ( Edge w = G.first(v); G.isEdge(w); w = G.next(w))
if (G.getMark(G.v2(w)) = = UNVISITED)
DFS ( G, G.v2(w));
PostVisit(G, v);
// Take appropriate action
}
E.G.M. Petrakis
Graphs
40
BFS Algorithm
void BFS (Graph G, int start) {
Queue Q(G.n( ));
Q.enqueue(start);
G.setMark(start, VISITED);
while ( !Q.isEmpty( ))
{
int v = Q.dequeue( );
PreVisit(G, v);
// Take appropriate action
for ( Edge w = G.first(v); G.isEdge(w); w = G.next(w))
if (G.getMark(G.v2(w)) = = UNVISITED) {
G.setMark(G.v2(w), VISITED); Q.enqueue(G.v2(w));
}
PostVisit(G, v);
// Take appropriate action
}
}
E.G.M. Petrakis
Graphs
41
Connected - Unconnected
B
A
C
D
connected graph: undirected
graph, there is a path
connecting any two nodes
E
A
E
B
C
unconnected graph:
not always a path
F
G
D
connected components
E.G.M. Petrakis
Graphs
42
Connected Components
 If there exist unconnected nodes in a DFS or BFS
traversal of G then G is unconnected
 Find all connected components:
void COMP(G, n)
{
for i = 1 to n
if Mark(i) == UNVISITED
then DFS(i) [or BFS(i)];
}
 Complexity: O(|V| + |E|)
E.G.M. Petrakis
Graphs
43
Spanning Trees
Tree formed from edges and nodes of G
(G,E)
Spanning Tree
E.G.M. Petrakis
Graphs
44
Spanning Forest
 Set of disjoint spanning trees Ti of G=(V,E)
 Ti = ( Vi , Ei ) 1≤ i ≤ k, Vi,Ei:subsets of V, E
 DFS produces depth first spanning trees
or forest
 BFS breadth first spanning trees or forest
 Undirected graphs provide more traversals
 produce less but short spanning trees
 Directed graphs provide less traversals
 produce more and higher spanning trees
E.G.M. Petrakis
Graphs
45
DFS
A
A
B
C
D
E
DFS
C
D
A
B
F
C
DFS spanning tree
B
E
A
C
E
B
D
D
F
G
E.G.M. Petrakis
DFS
E
Graphs
DFS spanning forest
G
46
BFS
A
A
B
C
D
E
F
G
BFS spanning tree
ΒFS
B
E
C
D
F
G
A
A
B
F
ΒFS
C
C
B
D
F
H
E
E
BFS spanning
forest
D
E.G.M. Petrakis H
Graphs
47
Min. Cost Spanning Tree
1
6
2
3
5
1
3
6
5
5
4
6
Prim’s algorithm:
Complexity O(|V|2)
5
4
2
6
1
1
1
1
1
1
3
1
3
1
3
1
3
1
3
4
6
4
4
2
2
5
4
4
6
6
2
2
3
5
4
4
5
2
6
costT = 1 + 5 + 2 + 4 + 3
E.G.M. Petrakis
Graphs
48
Prim’s Algorithm
static void Prim(Graph G, int s, int[] D )
{//prim’s MST algorithm
int[] V = new int[G.n( )];
// who’s closest
for (int i=0; i<G.n( ); i++) D[i] = INFINITY; // initialize
D[s] = 0;
for ( i=0; i<G.n( ); i++) {
// process the vertices
int v = minVertex(G, D);
G.setMark(v], VISITED);
if ( v != s ) AddEdgetoMST(V[v], v); // add this edge to MST
if (D[v] == INFINITY ) return;
// unreachable vertices
for ( Edge w = G.first(v); G.isEdge(w); w = G.next(w))
if (D[G.v2(w)] > G.weight(w)) {
D[G.v2(w)] = G.weight(w);
// update distance and
V[G.v2(w)] = v;
// who it came from
}
}
}
E.G.M. Petrakis
Graphs
49
Prim’s Algorithm (cont.)
// find min cost vertex
static int minVertex(Graph G, int[] D ) {
int v = 0;
for (int i = 0; i < G.n( ); i++)
// initialize
if (G.getMark(i) == UNVISITED) { v = i; break; }
for ( i=0; i<G.n( ); i++)
// find smallest value
if ((G.getMark(i) == UNVISITED) && ( D[i] < D[v] ))
v = i;
return v;
}
E.G.M. Petrakis
Graphs
50
Dijkstra’s Algorithm
 Find the shortest path from a given node
to every other node in a graph G
 no better algorithm for single ending node
 Notation:
G = (V,E) : input graph
C[i,j] : distance between nodes i, j
V : starting node
S : set of nodes for which the shortest path
from v has been computed
 D(W) : length of shortest path from v to w
passing through nodes in S




E.G.M. Petrakis
Graphs
51
starting point: v = 1
1
100
10
2
30
5
50
10
60
3
20
4
step
S
W
D(2)
D(3)
D(4)
D(5)
1
{1}
-
10
infinite
30
100
2
{1,2}
2
10
60
30
100
3
{1,2,4}
4
10
50
30
90
4
{1,2,4,3}
3
10
50
30
60
5
{1,2,4,3,5}
5
10
50
30
60
E.G.M. Petrakis
Graphs
52
Dijkstra’s Algorithm (cont.)
Dijkstra(G: graph, int v) {
S = {1};
for i = 2 to n D[i] = C[i,j];
while (S != V) {
choose w from V-S: D[w] = minimum
S = S + {w};
for each v in V–S: D[v] = min{D[v], D[w]+[w,v]}*;
}
}
* If D[w]+C[w,v] < D[v] then P[v] = w: keep path in array
E.G.M. Petrakis
Graphs
53
Compute Shortest Path
static void Dijkstra(Graph G, int s, int[] D) {
for (int i=0; i < G.n( ); i++)
// initialize
D[i] = INFINITY;
D[s] = 0;
for (i = 0; i < G.n( ); i++) {
// process the vertices
int v = minVertex(G, D);
G.setMark(v, VISITED);
if (D[v] == INFINITY) return; // remaining vertices unreachable
for (Edge w = G.first(v); G.isEdge(w); w = G.next(w))
if (D[G.v2(w)] > (D[v] + G.weight(w)))
D[G.v2(w)] = D[v] + G.weight(w);
}
}
E.G.M. Petrakis
Graphs
54
Find Min. Cost Vertex
static int minVertex(Graph G, int[] D) {
int v=0;
for (int i = 0; i < G.n( ); i++)
if (G.getMark(i) == UNVISITED) { v = i; break; }
for (i++; i < G.n( ); i++)
// find smallest D value
if ((G.getMark(i) == UNVISITED) && (D[i] < D[v])) v = i;
return v;
}
 minVertex: scans through the list of vertices for the min.
value  O(|V|) time
 Complexity: O(|V|2 + |E|) = O(|V|2) since O(|E|) is O(|V|2)
E.G.M. Petrakis
Graphs
55