2IS80 Fundamentals of Informatics
Fall 2015
Lecture 7: Sorting and Directed Graphs
Sorting algorithmsInput: a sequence of n numbers ‹a1, a2, …, an›Output: a permutation of the input such that ‹ai1 ≤ … ≤ ain›
Important properties of sorting algorithms:
running time: how fast is the algorithm in the worst case
in place: only a constant number of input elements are ever stored outside the input array
Sorting algorithmsInput: a sequence of n numbers ‹a1, a2, …, an›Output: a permutation of the input such that ‹ai1 ≤ … ≤ ain›
Important properties of sorting algorithms:
running time: how fast is the algorithm in the worst case
in place: only a constant number of input elements are ever stored outside the input array
Θ(n2)yes
Θ(n log n) no
worst case running time in place
Selection Sort
Insertion Sort
Merge Sort
Θ(n2)yes
QuickSort
One more sorting algorithm …
worst case running time in place
Selection Sort Θ(n2) yes
Insertion Sort Θ(n2) yes
Merge Sort Θ(n log n) no
Quick Sort Θ(n2) yes
QuickSort
Why QuickSort?
1. Expected running time: Θ(n log n) (randomized QuickSort)
2. Constants hidden in Θ(n log n) are small
3. using linear time median finding to guarantee good pivot gives worst case Θ(n log n)
QuickSort QuickSort is a divide-and-conquer algorithm
To sort the subarray A[p..r]:
DividePartition A[p..r] into two subarrays A[p..q-1] and A[q+1..r], such that each element in A[p..q-1] is ≤ A[q] and A[q] is < each element in A[q+1..r].
ConquerSort the two subarrays by recursive calls to QuickSort
CombineNo work is needed to combine the subarrays, since they are sorted in place.
Divide using a procedure Partition which returns q.
QuickSortQuickSort(A, p, r) 1. if p < r2. then q = Partition(A, p, r)3. QuickSort(A, p, q-1)4. QuickSort(A, q+1, r)
Partition(A, p, r)5. x = A[r]6. i = p-17. for j = p to r-18. do if A[j] ≤ x9. then i = i+110. exchange A[i] ↔ A[j]11. exchange A[i+1] ↔ A[r]12. return i+1
Initial call: QuickSort(A, 1, n)
Partition always selects A[r] as the pivot (the element around which to partition)
Partition As Partition executes, the array
is partitioned into four regions (some may be empty)
Loop invariant1. all entries in A[p..i] are ≤ pivot2. all entries in A[i+1..j-1] are > pivot3. A[r] = pivot
Partition(A, p, r)1. x = A[r]2. i = p-13. for j = p to r-14. do if A[j] ≤ x5. then i = i+16. exchange A[i] ↔ A[j]7. exchange A[i+1] ↔ A[r]8. return i+1
x
p i j r
≤ x > x ???
Partition
xp i j r
≤ x > x ???
Partition(A, p, r)1. x = A[r]2. i = p-13. for j = p to r-14. do if A[j] ≤ x5. then i = i+16. exchange A[i] ↔ A[j]7. exchange A[i+1] ↔ A[r]8. return i+18 1 6 4 0 3 9 5
pi j r
8 1 6 4 0 3 9 5pi j r
1 8 6 4 0 3 9 5pi j r
1 4 6 8 0 3 9 5p i j r
1 8 6 4 0 3 9 5pi j r
1 4 0 8 6 3 9 5p i j r
1 4 0 3 6 8 9 5p i j r
1 4 0 3 6 8 9 5p i r
1 4 0 3 5 8 9 6p i r
Loop invariant1. all entries in A[p..i] are ≤ pivot2. all entries in A[i+1..j-1] are > pivot3. A[r] = pivot
Initializationbefore the loop starts, all conditions are satisfied, since r is the pivot and the two subarrays A[p..i] and A[i+1..j-1] are empty
Maintenancewhile the loop is running, if A[j] ≤ pivot, then A[j] and A[i+1] are swapped and then i and j are incremented ➨ 1. and 2. hold.If A[j] > pivot, then increment only j ➨ 1. and 2. hold.
Partition - CorrectnessPartition(A, p, r)1. x = A[r]2. i = p-13. for j = p to r-14. do if A[j] ≤ x5. then i = i+16. exchange A[i] ↔ A[j]7. exchange A[i+1] ↔ A[r]8. return i+1
xp i j
≤ x > x ???
r
Loop invariant1. all entries in A[p..i] are ≤ pivot2. all entries in A[i+1..j-1] are > pivot3. A[r] = pivot
Terminationwhen the loop terminates, j = r, so all elements in A are partitioned into one of three cases:
A[p..i] ≤ pivot, A[i+1..r-1] > pivot, and A[r] = pivot
Lines 7 and 8 move the pivot between the two subarrays
Running time:
Partition - CorrectnessPartition(A, p, r)1. x = A[r]2. i = p-13. for j = p to r-14. do if A[j] ≤ x5. then i = i+16. exchange A[i] ↔ A[j]7. exchange A[i+1] ↔ A[r]8. return i+1
xp i j
≤ x > x ???
r
Θ(n) for an n-element subarray
QuickSort: running timeQuickSort(A, p, r) 1. if p < r2. then q = Partition(A, p, r)3. QuickSort(A, p, q-1)4. QuickSort(A, q+1, r)
Running time depends on partitioning of subarrays: if they are balanced, then QuickSort is as fast as MergeSort if they are unbalanced, then QuickSort can be as slow as
InsertionSort
Worst case
subarrays completely unbalanced: 0 elements in one, n-1 in the other
T(n) = T(n-1) + T(0) + Θ(n) = T(n-1) + Θ(n) = Θ(n2) input: sorted array
QuickSort: running timeQuickSort(A, p, r) 1. if p < r2. then q = Partition(A, p, r)3. QuickSort(A, p, q-1)4. QuickSort(A, q+1, r)
Running time depends on partitioning of subarrays: if they are balanced, then QuickSort is as fast as MergeSort if they are unbalanced, then QuickSort can be as slow as
InsertionSort
Best case
subarrays completely balanced: each has ≤ n/2 elements T(n) = 2T(n/2) + Θ(n) = Θ(n log n)
Average? Much closer to best case than worst case …
Randomized QuickSort pick pivot at random
RandomizedPartition(A, p, r) 1. i = Random(p, r)2. exchange A[r] ↔A[i]3. return Partition(A, p, r)
random pivot results in reasonably balanced split on average ➨ expected running time Θ(n log n)
alternative: use linear time median finding to find a good pivot ➨ worst case running time Θ(n log n)
price to pay: added complexity
Graphs
Networks and other graphsroad network computer network
execution order for processes
process 1
process 2process 3
process 5
process 4process 6
Graphs: Basic definitions and terminology A graph G is a pair G = (V, E)
V is the set of nodes or vertices of G E ⊂ VxV is the set of edges or arcs of G
If (u, v) E then vertex v is ∈ adjacent to vertex u
directed graph (u, v) is an ordered pair
➨ (u, v) ≠ (v, u) self-loops possible
undirected graph (u, v) is an unordered pair
➨ (u, v) = (v, u) self-loops forbidden
Some special graphsTree
connected, undirected, acyclic graph
Every tree with n vertices has exactly n-1 edges
DAGdirected, acyclic graph
in-degreenumber of incoming edges
out-degreenumber of outgoing edges
every DAG has a vertex with in-degree 0 and with out-degree 0 …
Topological sort
Topological sortInput: directed, acyclic graph (DAG) G = (V, E)Output: a linear ordering of v1 ,v2 ,…, vn of the vertices such that
if (vi ,vj ) ∈ E then i < j
DAGs are useful for modeling processes and structures that have a partial order
Partial order a > b and b > c ➨ a > c but may have a and b such that neither a > b nor b > a
execution order for processes
process 1
process 2process 3
process 5
process 4process 6
Topological sortInput: directed, acyclic graph (DAG) G = (V, E)Output: a linear ordering of v1 ,v2 ,…, vn of the vertices such that
if (vi ,vj ) ∈ E then i < j
DAGs are useful for modeling processes and structures that have a partial order
Partial order a > b and b > c ➨ a > c but may have a and b such that neither a > b nor b > a
a partial order can always be turned into a total order(either a > b or b > a for all a ≠ b)
(that’s what a topological sort does …)
Input: directed, acyclic graph (DAG) G = (V, E)Output: a linear ordering of v1 ,v2 ,…, vn of the vertices such that
if (vi ,vj ) ∈ E then i < j
Every directed, acyclic graph has a topological order
Topological sort
v6v5v2 v3 v4v1
Topological sortunderwear
pants
belt
socks
shoes
shirt
tie
jacket
watch
watch socks underwear pants shoes shirt tie belt jacket
Topological sortunderwear
pants
belt
socks
shoes
shirt
tie
jacket
watch
watch socks underwear pants shoes shirt tie belt jacket
Topological sortunderwear
pants
belt
socks
shoes
shirt
tie
jacket
watch
watchsocksunderwear pants shoes shirt tie belt jacket
Topological sortunderwear
pants
belt
socks
shoes
shirt
tie
jacket
watch
watchsocksunderwear pants shoes shirt tiebelt jacket
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 05. While next is not empty do the following:
A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v into next
6. Return the linear order
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 0 0 0 0 0 0 0
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 1 0 1 0 0 0 0
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 2 0 1 0 0 0 0
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 3 0 1 1 0 0 0
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 3 0 1 1 0 0 1
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 3 0 1 2 0 1 1
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 3 0 1 2 0 1 2
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 3 0 1 2 0 1 2
1 2 4 7
7
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
next
linear order
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 3 0 1 1 0 0 2
1 2 4 7
7
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
next
linear order
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 3 0 1 1 0 0 2
1 2 4 8
7 8
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
next
linear order
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 3 0 1 1 0 0 1
1 2 4 8
7 8
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
next
linear order
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 3 0 1 1 0 0 1
1 2 4
7 8 4 2
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
next
linear order
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 2 0 1 1 0 0 1
1 2
7 8 4 2
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
next
linear order
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 2 0 1 1 0 0 1
1
7 8 4 2 1
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
next
linear order
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 1 0 0 1 0 0 1
1
7 8 4 2 1
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
next
linear order
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 1 0 0 1 0 0 1
5
7 8 4 2 1 5
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
next
linear order
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 0 0 0 0 0 0 1
5
7 8 4 2 1 5
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
next
linear order
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 0 0 0 0 0 0 1
3 6
7 8 4 2 1 5 6
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
next
linear order
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1 2
3 4
6
5
7
8
9
in-degree 0 0 0 0 0 0 0 0 0
3 6
7 8 4 2 1 5 6
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
next
linear order
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1
in-degree 0 0 0 0 0 0 0 0 0
3 9
7 8 4 2 1 5 6 9 3
2
3 4
6
5
7
8
9
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
next
linear order
Topological sortunderwear
pants
belt
socks
shoes
shirt
tie
jacket
watch
watch socks underwear pants shoesshirt tie belt jacket
1 2 3 4 5 6 7 8 9
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert v
into next6. Return the linear order
1
in-degree 0 0 0 0 0 0 0 0 0
7 8 4 2 1 5 6 9 3
2
3 4
6
5
7
8
9
underwear
pants
belt
socks
shoes
shirt
tie
jacket
watch1 2
3 4
6
5
7
8
9
next
linear order
Running time?
Graph representationGraph G = (V, E)
1. Adjacency listsarray Adj of |V| lists, one per vertex
Adj[u] = linked list of all vertices v with (u, v) E ∈
(works for both directed and undirected graphs)
54 3
21
3
3
1 4
1
5
4
3
2
2
2
3
1
Graph G = (V, E)
1. Adjacency listsarray Adj of |V| lists, one per vertex
Adj[u] = linked list of all vertices v with (u, v) E ∈
(works for both directed and undirected graphs)
Graph representation
54 3
21
1
1
5
4
3
2
2
2
3
Graph G = (V, E)
1. Adjacency listsarray Adj of |V| lists, one per vertex
Adj[u] = linked list of all vertices v with (u, v) E∈
2. Adjacency matrix |V| x |V| matrix A = (aij)
(also works for both directed and undirected graphs)
Graph representation
aij = 1 if (i, j) E∈0 otherwise
12345
31 2 4 51
11
11
1 11
54 3
21
Graph G = (V, E)
1. Adjacency listsarray Adj of |V| lists, one per vertex
Adj[u] = linked list of all vertices v with (u, v) E∈
2. Adjacency matrix |V| x |V| matrix A = (aij)
(also works for both directed and undirected graphs)
Graph representation
aij = 1 if (i, j) E∈0 otherwise
12345
31 2 4 51
1
1 1
54 3
21
Adjacency lists vs. adjacency matrix3
3
1 4
1
5
4
3
2
2
2
3
112345
31 2 4 51
11
11
1 11
Adjacency lists Adjacency matrix
Space
Timeto list all vertices adjacent to u
Timeto check if (u, v) E∈
Θ(V + E) Θ(V2)
Θ(degree(u)) Θ(V)
Θ(1)Θ(degree(u))better if the graph is sparse … use V for |V| and E for |E|
Topological sortTopological-Sort(G)
Input: a DAG G with vertices 1 .. nOutput: A linear order of the vertices, such that u appears before v if (u, v) in G
1. Let in-degree[1..n] be a new array2. Set all values in in-degree to 03. For each vertex u
A. For each vertex v adjacent to u:i. Increment in-degree[v]
4. Make a list next consisting of all vertices u such that in-degree[u] = 0
5. While next is not empty do the following:A. Delete a vertex from next and call it uB. Add u to the end of the linear orderC. For each vertex v adjacent to u:
i. Decrement in-degree[v]ii. If in-degree[v] = 0 then insert
v into next6. Return the linear order
Running time?
DAG G represented in adjacency list
next is a linked list G has n vertices and m edges
1. Θ(1)2. Θ(n)3. Θ(n+m)4. Θ(n)5. Θ(n+m)6. Θ(1)
Θ(n+m)
Top Related