CSE332: Data Structures & Algorithms

Lecture 14: Introduction to Graphs

Aaron Bauer
Winter 2014
Announcements

• Reminder: HW4 partner selection due on Wednesday

• Extra office hours Tuesday, 4:30-5:30 in Bagley 154
• TA session Thursday, 4:30-5:30 in Bagley 154
– Union-find and homework 4

Winter 2014 CSE373: Data Structures & Algorithms 2

 Graphs
• A graph is a formalism for representing relationships among items
– Very general definition because very general concept

• A graph is a pair Han Luke

G = (V,E)
– A set of vertices, also known as nodes
Leia
V = {v1,v2,…,vn}
– A set of edges V = {Han,Leia,Luke}
E = {e1,e2,…,em} E = {(Luke,Leia),
(Han,Leia),
• Each edge ei is a pair of vertices
(Leia,Han)}
(vj,vk)
• An edge “connects” the vertices

• Graphs can be directed or undirected

Winter 2014 CSE373: Data Structures & Algorithms 3
Undirected Graphs

• In undirected graphs, edges have no specific direction

– Edges are always “two-way”
D

A
C

• Thus, (u,v) ∈ E implies (v,u) ∈ E

– Only one of these edges needs to be in the set
– The other is implicit, so normalize how you check for it

• Degree of a vertex: number of edges containing that vertex

– Put another way: the number of adjacent vertices
Winter 2014 CSE373: Data Structures & Algorithms 4
Directed Graphs
• In directed graphs (sometimes called digraphs), edges have a
direction
D
A
C
A or
C
2 edges here B
B
• Thus, (u,v) ∈ E does not imply (v,u) ∈ E.
• Let (u,v) ∈ E mean u → v
• Call u the source and v the destination
• In-degree of a vertex: number of in-bound edges,
i.e., edges where the vertex is the destination
• Out-degree of a vertex: number of out-bound edges
i.e., edges where the vertex is the source

Winter 2014 CSE373: Data Structures & Algorithms 5

 Self-Edges, Connectedness

• A self-edge a.k.a. a loop is an edge of the form (u,u)

– Depending on the use/algorithm, a graph may have:
• No self edges
• Some self edges
• All self edges (often therefore implicit, but we will be explicit)

• A node can have a degree / in-degree / out-degree of zero

• A graph does not have to be connected

– Even if every node has non-zero degree

Winter 2014 CSE373: Data Structures & Algorithms 6

 D
More notation A
C

For a graph G = (V,E)

B

• |V| is the number of vertices

V = {A, B, C, D}
• |E| is the number of edges E = {(C, B),
– Minimum? (A, B),
– Maximum for undirected? (B, A)
– Maximum for directed? (C, D)}

Winter 2014 CSE373: Data Structures & Algorithms 7

 D
More notation A
C

For a graph G = (V,E)

B

• |V| is the number of vertices

V = {A, B, C, D}
• |E| is the number of edges E = {(C, B),
– Minimum? 0 (A, B),
– Maximum for undirected? (B, A)
– Maximum for directed? (C, D)}

Winter 2014 CSE373: Data Structures & Algorithms 8

 D
More notation A
C

For a graph G = (V,E)

B

• |V| is the number of vertices

• |E| is the number of edges
– Minimum? 0
– Maximum for undirected? |V||V+1|/2 ∈ O(|V|2)
– Maximum for directed?

Winter 2014 CSE373: Data Structures & Algorithms 9

 D
More notation A
C

For a graph G = (V,E)

B

• |V| is the number of vertices

• |E| is the number of edges
– Minimum? 0
– Maximum for undirected? |V||V+1|/2 ∈ O(|V|2)
– Maximum for directed? |V|2 ∈ O(|V|2)
(assuming self-edges allowed, else subtract |V|)

Winter 2014 CSE373: Data Structures & Algorithms 10

 D
More notation A
C

For a graph G = (V,E):

B

• |V| is the number of vertices

• |E| is the number of edges
– Minimum? 0
– Maximum for undirected? |V||V+1|/2 ∈ O(|V|2)
– Maximum for directed? |V|2 ∈ O(|V|2)
(assuming self-edges allowed, else subtract |V|)

• If (u,v) ∈ E
– Then v is a neighbor of u, i.e., v is adjacent to u
– Order matters for directed edges
• u is not adjacent to v unless (v,u) ∈ E
Winter 2014 CSE373: Data Structures & Algorithms 11
Examples again
Which would use directed edges? Which would have self-edges?
Which would be connected? Which could have 0-degree nodes?

1. Web pages with links

2. Facebook friends
3. “Input data” for the Kevin Bacon game
4. Methods in a program that call each other
5. Road maps (e.g., Google maps)
6. Airline routes
7. Family trees
8. Course pre-requisites

Winter 2014 CSE373: Data Structures & Algorithms 12

Weighted Graphs
• In a weighed graph, each edge has a weight a.k.a. cost
– Typically numeric (most examples use ints)
– Orthogonal to whether graph is directed
– Some graphs allow negative weights; many do not
Clinton 20
Mukilteo

Kingston 30 Edmonds

Bainbridge 35
Seattle

60
Bremerton
Winter 2014 CSE373: Data Structures & Algorithms 13
Examples

What, if anything, might weights represent for each of these?

Do negative weights make sense?

• Web pages with links

• Facebook friends
• “Input data” for the Kevin Bacon game
• Methods in a program that call each other
• Road maps (e.g., Google maps)
• Airline routes
• Family trees
• Course pre-requisites

Winter 2014 CSE373: Data Structures & Algorithms 14

 Paths and Cycles

• A path is a list of vertices [v0,v1,…,vn] such that (vi,vi+1)∈

E for all 0 ≤ i < n. Say “a path from v0 to vn”

• A cycle is a path that begins and ends at the same node (v0==vn)
Chicago
Seattle

Salt Lake City

San Francisco
Dallas
Example: [Seattle, Salt Lake City, Chicago, Dallas, San Francisco, Seattle]
Winter 2014 CSE373: Data Structures & Algorithms 15
 Path Length and Cost
• Path length: Number of edges in a path
• Path cost: Sum of weights of edges in a path

Example where
P= [Seattle, Salt Lake City, Chicago, Dallas, San Francisco, Seattle]

3.5 Chicago
Seattle
2 2
length(P) = 5
2 Salt Lake City
2.5 cost(P) = 11.5
2.5 2.5

3
San Francisco Dallas
Winter 2014 CSE373: Data Structures & Algorithms 16
Simple Paths and Cycles

• A simple path repeats no vertices, except the first might be the

last
[Seattle, Salt Lake City, San Francisco, Dallas]
[Seattle, Salt Lake City, San Francisco, Dallas, Seattle]

• Recall, a cycle is a path that ends where it begins

[Seattle, Salt Lake City, San Francisco, Dallas, Seattle]
[Seattle, Salt Lake City, Seattle, Dallas, Seattle]

• A simple cycle is a cycle and a simple path

[Seattle, Salt Lake City, San Francisco, Dallas, Seattle]

Winter 2014 CSE373: Data Structures & Algorithms 17

Paths and Cycles in Directed Graphs

Example:
D

A C

Is there a path from A to D?

Does the graph contain any cycles?

Winter 2014 CSE373: Data Structures & Algorithms 18

Paths and Cycles in Directed Graphs

Example:
D

A C

Is there a path from A to D? No

Does the graph contain any cycles?

Winter 2014 CSE373: Data Structures & Algorithms 19

Paths and Cycles in Directed Graphs

Example:
D

A C

Is there a path from A to D? No

Does the graph contain any cycles? No

Winter 2014 CSE373: Data Structures & Algorithms 20

Undirected-Graph Connectivity

• An undirected graph is connected if for all

pairs of vertices u,v, there exists a path from u to v

Connected graph Disconnected graph

• An undirected graph is complete, a.k.a. fully connected if for all

pairs of vertices u,v, there exists an edge from u to v

plus self edges

Winter 2014 CSE373: Data Structures & Algorithms 21
Directed-Graph Connectivity

• A directed graph is strongly connected if

there is a path from every vertex to every
other vertex

• A directed graph is weakly connected if

there is a path from every vertex to every
other vertex ignoring direction of edges

• A complete a.k.a. fully connected directed

graph has an edge from every vertex to
every other vertex
plus self edges
Winter 2014 CSE373: Data Structures & Algorithms 22
Examples

For undirected graphs: connected?

For directed graphs: strongly connected? weakly connected?

• Web pages with links

• Facebook friends
• “Input data” for the Kevin Bacon game
• Methods in a program that call each other
• Road maps (e.g., Google maps)
• Airline routes
• Family trees
• Course pre-requisites
• …

Winter 2014 CSE373: Data Structures & Algorithms 23

Trees as Graphs

When talking about graphs, Example:

we say a tree is a graph that is: D E
– Undirected
B
– Acyclic
– Connected
A
So all trees are graphs, but not
all graphs are trees C

How does this relate to the trees F

we know and love?...
G H

Winter 2014 CSE373: Data Structures & Algorithms 24

Rooted Trees
• We are more accustomed to rooted trees where:
– We identify a unique root
– We think of edges as directed: parent to children

• Given a tree, picking a root gives a unique rooted tree

– The tree is just drawn differently and with undirected edges
D E
B A
redrawn
A B C

C D E F
F
G H
G H
Winter 2014 CSE373: Data Structures & Algorithms 25
Rooted Trees
• We are more accustomed to rooted trees where:
– We identify a unique root
– We think of edges as directed: parent to children

• Given a tree, picking a root gives a unique rooted tree

– The tree is just drawn differently and with undirected edges
D E F
B
redrawn G H C
A
A
C
B
F
D E
G H
Winter 2014 CSE373: Data Structures & Algorithms 26
Directed Acyclic Graphs (DAGs)
• A DAG is a directed graph with no (directed) cycles
– Every rooted directed tree is a DAG
– But not every DAG is a rooted directed tree

– Every DAG is a directed graph

– But not every directed graph is a DAG

Winter 2014 CSE373: Data Structures & Algorithms 27

Examples

Which of our directed-graph examples do you expect to be a DAG?

• Web pages with links

• “Input data” for the Kevin Bacon game
• Methods in a program that call each other
• Airline routes
• Family trees
• Course pre-requisites

Winter 2014 CSE373: Data Structures & Algorithms 28

Density / Sparsity

• Recall: In an undirected graph, 0 ≤ |E| < |V|2

• Recall: In a directed graph: 0 ≤ |E| ≤ |V|2
• So for any graph, O(|E|+|V|2) is O(|V|2)
• Another fact: If an undirected graph is connected, then |V|-1 ≤ |E|

• Because |E| is often much smaller than its maximum size, we do not
always approximate |E| as O(|V|2)
– This is a correct bound, it just is often not tight
– If it is tight, i.e., |E| is Θ(|V|2) we say the graph is dense
• More sloppily, dense means “lots of edges”
– If |E| is O(|V|) we say the graph is sparse
• More sloppily, sparse means “most possible edges missing”

Winter 2014 CSE373: Data Structures & Algorithms 29

What is the Data Structure?
• So graphs are really useful for lots of data and questions
– For example, “what’s the lowest-cost path from x to y”

• But we need a data structure that represents graphs

• The “best one” can depend on:

– Properties of the graph (e.g., dense versus sparse)
– The common queries (e.g., “is (u,v) an edge?” versus
“what are the neighbors of node u?”)

• So we’ll discuss the two standard graph representations

– Adjacency Matrix and Adjacency List
– Different trade-offs, particularly time versus space

Winter 2014 CSE373: Data Structures & Algorithms 30

Adjacency Matrix

• Assign each node a number from 0 to |V|-1

• A |V| x |V| matrix (i.e., 2-D array) of Booleans (or 1 vs. 0)
– If M is the matrix, then M[u][v] being true
means there is an edge from u to v

0 1 2 3
D(3) 0 F T F F
A(0) C(2) 1 T F F F

B(1) 2 F T F T

3 F F F F
Winter 2014 CSE373: Data Structures & Algorithms 31
Adjacency Matrix Properties
0 1 2 3
• Running time to:
0 F T F F
– Get a vertex’s out-edges:
– Get a vertex’s in-edges:
1 T F F F
– Decide if some edge exists:
– Insert an edge: F T F T
2
– Delete an edge:
3 F F F F
• Space requirements:

• Best for sparse or dense graphs?

Winter 2014 CSE373: Data Structures & Algorithms 32

Adjacency Matrix Properties
0 1 2 3
0 F T F F
• Running time to:
– Get a vertex’s out-edges: O(|V|) 1 T F F F
– Get a vertex’s in-edges:
– Decide if some edge exists: 2 F T F T
– Insert an edge:
3 F F F F
– Delete an edge:

• Space requirements:

• Best for sparse or dense graphs?

Winter 2014 CSE373: Data Structures & Algorithms 33

Adjacency Matrix Properties
0 1 2 3
0 F T F F
• Running time to:
– Get a vertex’s out-edges: O(|V|) 1 T F F F
– Get a vertex’s in-edges: O(|V|)
– Decide if some edge exists: 2 F T F T
– Insert an edge:
3 F F F F
– Delete an edge:

• Space requirements:

• Best for sparse or dense graphs?

Winter 2014 CSE373: Data Structures & Algorithms 34

Adjacency Matrix Properties
0 1 2 3
0 F T F F
• Running time to:
– Get a vertex’s out-edges: O(|V|) 1 T F F F
– Get a vertex’s in-edges: O(|V|)
– Decide if some edge exists: O(1) 2 F T F T
– Insert an edge:
3 F F F F
– Delete an edge:

• Space requirements:

• Best for sparse or dense graphs?

Winter 2014 CSE373: Data Structures & Algorithms 35

Adjacency Matrix Properties
0 1 2 3
0 F T F F
• Running time to:
– Get a vertex’s out-edges: O(|V|) 1 T F F F
– Get a vertex’s in-edges: O(|V|)
– Decide if some edge exists: O(1) 2 F T F T
– Insert an edge: O(1)
3 F F F F
– Delete an edge:

• Space requirements:

• Best for sparse or dense graphs?

Winter 2014 CSE373: Data Structures & Algorithms 36

Adjacency Matrix Properties
0 1 2 3
0 F T F F
• Running time to:
– Get a vertex’s out-edges: O(|V|) 1 T F F F
– Get a vertex’s in-edges: O(|V|)
– Decide if some edge exists: O(1) 2 F T F T
– Insert an edge: O(1)
3 F F F F
– Delete an edge: O(1)

• Space requirements:

• Best for sparse or dense graphs?

Winter 2014 CSE373: Data Structures & Algorithms 37

Adjacency Matrix Properties
0 1 2 3
0 F T F F
• Running time to:
– Get a vertex’s out-edges: O(|V|) 1 T F F F
– Get a vertex’s in-edges: O(|V|)
– Decide if some edge exists: O(1) 2 F T F T
– Insert an edge: O(1)
3 F F F F
– Delete an edge: O(1)

• Space requirements:
– |V|2 bits

• Best for sparse or dense graphs?

Winter 2014 CSE373: Data Structures & Algorithms 38

Adjacency Matrix Properties
0 1 2 3
0 F T F F
• Running time to:
– Get a vertex’s out-edges: O(|V|) 1 T F F F
– Get a vertex’s in-edges: O(|V|)
– Decide if some edge exists: O(1) 2 F T F T
– Insert an edge: O(1)
3 F F F F
– Delete an edge: O(1)

• Space requirements:
– |V|2 bits

• Best for sparse or dense graphs?

– Best for dense graphs

Winter 2014 CSE373: Data Structures & Algorithms 39

Adjacency Matrix Properties

• How will the adjacency matrix vary for an undirected graph?

• How can we adapt the representation for weighted graphs?

0 1 2 3
0 F T F F

1 T F F F

2 F T F T

3 F F F F
Winter 2014 CSE373: Data Structures & Algorithms 40
Adjacency Matrix Properties

• How will the adjacency matrix vary for an undirected graph?

– Undirected will be symmetric around the diagonal

• How can we adapt the representation for weighted graphs?

0 1 2 3
0 F T F F

1 T F F F

2 F T F T

3 F F F F
Winter 2014 CSE373: Data Structures & Algorithms 41
Adjacency Matrix Properties

• How will the adjacency matrix vary for an undirected graph?

– Undirected will be symmetric around the diagonal

• How can we adapt the representation for weighted graphs?

– Instead of a Boolean, store a number in each cell
– Need some value to represent ‘not an edge’
• In some situations, 0 or -1 works 0 1 2 3
0 F T F F

1 T F F F

2 F T F T

3 F F F F
Winter 2014 CSE373: Data Structures & Algorithms 42
Adjacency List

• Assign each node a number from 0 to |V|-1

• An array of length |V| in which each entry stores a list of all
adjacent vertices (e.g., linked list)

D(3) 0 1 /
A(0) C(2) 1 0 /

B(1) 2 3 1 /

3 /

Winter 2014 CSE373: Data Structures & Algorithms 43

 0 1 /
Adjacency List Properties
1 0 /
• Running time to:
– Get all of a vertex’s out-edges: 2 3 1 /

3 /
– Get all of a vertex’s in-edges:

– Decide if some edge exists:

– Insert an edge:
– Delete an edge:
• Space requirements:

• Best for dense or sparse graphs?

Winter 2014 CSE373: Data Structures & Algorithms 44

 0 1 /
Adjacency List Properties
1 0 /
• Running time to:
– Get all of a vertex’s out-edges: 2 3 1 /
O(d) where d is out-degree of vertex
3 /
– Get all of a vertex’s in-edges:

– Decide if some edge exists:

– Insert an edge:
– Delete an edge:
• Space requirements:

• Best for dense or sparse graphs?

Winter 2014 CSE373: Data Structures & Algorithms 45

 0 1 /
Adjacency List Properties
1 0 /
• Running time to:
– Get all of a vertex’s out-edges: 2 3 1 /
O(d) where d is out-degree of vertex
3 /
– Get all of a vertex’s in-edges:
O(|E|) (but could keep a second adjacency list for this!)
– Decide if some edge exists:

– Insert an edge:
– Delete an edge:
• Space requirements:

• Best for dense or sparse graphs?

Winter 2014 CSE373: Data Structures & Algorithms 46

 0 1 /
Adjacency List Properties
1 0 /
• Running time to:
– Get all of a vertex’s out-edges: 2 3 1 /
O(d) where d is out-degree of vertex
3 /
– Get all of a vertex’s in-edges:
O(|E|) (but could keep a second adjacency list for this!)
– Decide if some edge exists:
O(d) where d is out-degree of source
– Insert an edge:
– Delete an edge:
• Space requirements:

• Best for dense or sparse graphs?

Winter 2014 CSE373: Data Structures & Algorithms 47

 0 1 /
Adjacency List Properties
1 0 /
• Running time to:
– Get all of a vertex’s out-edges: 2 3 1 /
O(d) where d is out-degree of vertex
3 /
– Get all of a vertex’s in-edges:
O(|E|) (but could keep a second adjacency list for this!)
– Decide if some edge exists:
O(d) where d is out-degree of source
– Insert an edge: O(1) (unless you need to check if it’s there)
– Delete an edge:
• Space requirements:

• Best for dense or sparse graphs?

Winter 2014 CSE373: Data Structures & Algorithms 48

 0 1 /
Adjacency List Properties
1 0 /
• Running time to:
– Get all of a vertex’s out-edges: 2 3 1 /
O(d) where d is out-degree of vertex
3 /
– Get all of a vertex’s in-edges:
O(|E|) (but could keep a second adjacency list for this!)
– Decide if some edge exists:
O(d) where d is out-degree of source
– Insert an edge: O(1) (unless you need to check if it’s there)
– Delete an edge: O(d) where d is out-degree of source
• Space requirements:

• Best for dense or sparse graphs?

Winter 2014 CSE373: Data Structures & Algorithms 49

 0 1 /
Adjacency List Properties
1 0 /
• Running time to:
– Get all of a vertex’s out-edges: 2 3 1 /
O(d) where d is out-degree of vertex
3 /
– Get all of a vertex’s in-edges:
O(|E|) (but could keep a second adjacency list for this!)
– Decide if some edge exists:
O(d) where d is out-degree of source
– Insert an edge: O(1) (unless you need to check if it’s there)
– Delete an edge: O(d) where d is out-degree of source
• Space requirements:
– O(|V|+|E|)
• Best for dense or sparse graphs?

Winter 2014 CSE373: Data Structures & Algorithms 50

 0 1 /
Adjacency List Properties
1 0 /
• Running time to:
– Get all of a vertex’s out-edges: 2 3 1 /
O(d) where d is out-degree of vertex
3 /
– Get all of a vertex’s in-edges:
O(|E|) (but could keep a second adjacency list for this!)
– Decide if some edge exists:
O(d) where d is out-degree of source
– Insert an edge: O(1) (unless you need to check if it’s there)
– Delete an edge: O(d) where d is out-degree of source
• Space requirements:
– O(|V|+|E|)
• Best for dense or sparse graphs?
– Best for sparse graphs, so usually just stick with linked lists
Winter 2014 CSE373: Data Structures & Algorithms 51
 Undirected Graphs
Adjacency matrices & adjacency lists both do fine for undirected graphs
• Matrix: Can save roughly 2x space
– But may slow down operations in languages with “proper” 2D
arrays (not Java, which has only arrays of arrays)
– How would you “get all neighbors”?
• Lists: Each edge in two lists to support efficient “get all neighbors”
0 1 2 3
Example:
0 F T F
F F 0 1 /
D
A 1 T F TT F 1 0 /
C

2 F T F T 2 3 1 /
B
3 F F T F 3 /

Winter 2014 CSE373: Data Structures & Algorithms 52

Next…

Okay, we can represent graphs

Now let’s implement some useful and non-trivial algorithms

• Topological sort: Given a DAG, order all the vertices so that

every vertex comes before all of its neighbors

• Shortest paths: Find the shortest or lowest-cost path from x to y

– Related: Determine if there even is such a path

Winter 2014 CSE373: Data Structures & Algorithms 53

 Disclaimer: Do not use for official
Topological Sort advising purposes !

Problem: Given a DAG G=(V,E), output all vertices in an order such

that no vertex appears before another vertex that has an edge to it

Example input: XYZ

CSE 374
CSE 410
CSE 142 CSE 143 CSE 373
CSE 413

MATH 126 CSE 415

CSE 417
One example output:
126, 142, 143, 374, 373, 417, 410, 413, XYZ, 415
Winter 2014 CSE373: Data Structures & Algorithms 54
Questions and comments

• Why do we perform topological sorts only on DAGs?

– Because a cycle means there is no correct answer

• Is there always a unique answer?

– No, there can be 1 or more answers; depends on the graph
– Graph with 5 topological orders: 2
0 4
• Do some DAGs have exactly 1 answer? 3
– Yes, including all lists 1

• Terminology: A DAG represents a partial order and a topological

sort produces a total order that is consistent with it

Winter 2014 CSE373: Data Structures & Algorithms 55

Uses

• Figuring out how to graduate

• Computing an order in which to recompute cells in a spreadsheet

• Determining an order to compile files using a Makefile

• In general, taking a dependency graph and finding an order of

execution

• …

Winter 2014 CSE373: Data Structures & Algorithms 56

A First Algorithm for Topological Sort

1. Label (“mark”) each vertex with its in-degree

– Think “write in a field in the vertex”
– Could also do this via a data structure (e.g., array) on the side

2. While there are vertices not yet output:

a) Choose a vertex v with labeled with in-degree of 0
b) Output v and conceptually remove it from the graph
c) For each vertex u adjacent to v (i.e. u such that (v,u) in E),
decrement the in-degree of u

Winter 2014 CSE373: Data Structures & Algorithms 57