1 heaps chapter 6 in clrs. 2 motivation router: dijkstra’s algorithm for single source shortest...
Post on 22-Dec-2015
220 views
TRANSCRIPT
1
Heaps
Chapter 6 in CLRS
2
Motivation
• Router: • Dijkstra’s algorithm for single
source shortest path
• Prim’s algorithm for minimum spanning trees
3
Motivation
• Want to find the shortest route from New York to San Francisco
• Model the road-map with a graph
4
A Graph G=(V,E)
V is a set of vertices
E is a set of edges (pairs of vertices)
5
Model driving distances by weights on the edges
2 19
9
1
5
13
1710
148
21
V is a set of vertices
E is a set of edges (pairs of vertices)
6
Source and destination
V is a set of vertices
E is a set of edges (pairs of vertices)
2 19
9
1
5
13
1710
148
21
7
Dijkstra’s algorithm
• Assume all weights are non-negative
• Finds the shortest path from some fixed vertex s to every other vertex
8
s
s15
103
1
4
2s3
s2
s4
15 8
Example
9
Maintain an upper bound d(v) on the shortest path to v
0
∞
∞
∞
∞
s
s15
103
1
4
2s3
s2
s4
15 8
Example
10
s
s15
103
1
4
2s3
s2
s4
15 8
Maintain an upper bound d(v) on the shortest path to v
0
∞
∞
∞
∞
A node is either scanned (in S) or labeled (in Q)
Initially S = and Q = V
11
s
s15
103
1
4
2s3
s2
s4
15 8
Pick a vertex v in Q with minimum d(v) and add it to S
0
∞
∞
∞
∞
Initially S = and Q = V
12
s
s15
103
1
4
2s3
s2
s4
15 8
Pick a vertex v in Q with minimum d(v) and add it to S
0
∞
∞
∞
∞
Initially S = and Q = V
v
w15
For every edge (v,w) where w in Q relax(v,w)
13
s
s15
103
1
4
2s3
s2
s4
15 8
Relax(v,w)
If d(v) + w(v,w) < d(w) then d(w) ← d(v) + w(v,w) π(v) ← w
0
∞
∞
∞
∞
v
w
For every edge (v,w) where w in Q relax(v,w)
15
14
s
s15
103
1
4
2s3
s2
s4
15 8
0
∞
∞
∞
∞
S = {s}
Relax(s,s4)
15
s
s15
103
1
4
2s3
s2
s4
15 8
0
∞
∞
15
∞
Relax(s,s4)
S = {s}
16
s
s15
103
1
4
2s3
s2
s4
15 8
0
∞
∞
15
∞
Relax(s,s4)Relax(s,s3)
S = {s}
17
s
s15
103
1
4
2s3
s2
s4
15 8
0
∞
∞
15
10
Relax(s,s4)Relax(s,s3)
S = {s}
18
s
s15
103
1
4
2s3
s2
s4
15 8
0
∞
∞
15
10
Relax(s,s4)Relax(s,s3)Relax(s,s1)
S = {s}
19
s
s15
103
1
4
2s3
s2
s4
15 8
0
5
∞
15
10
Relax(s,s4)Relax(s,s3)Relax(s,s1)
S = {s}
20
s
s15
103
1
4
2s3
s2
s4
15 8
0
5
∞
15
10
S = {s}
Pick a vertex v in Q with minimum d(v) and add it to S
21
s
s15
103
1
4
2s3
s2
s4
15 8
0
5
∞
15
10
S = {s,s1}
Pick a vertex v in Q with minimum d(v) and add it to S
22
s
s15
103
1
4
2s3
s2
s4
15 8
0
5
∞
15
10
S = {s,s1}
Pick a vertex v in Q with minimum d(v) and add it to S
Relax(s1,s3)
23
s
s15
103
1
4
2s3
s2
s4
15 8
0
5
∞
15
9
S = {s,s1}
Pick a vertex v in Q with minimum d(v) and add it to S
Relax(s1,s3)
24
s
s15
103
1
4
2s3
s2
s4
15 8
0
5
∞
15
9
S = {s,s1}
Pick a vertex v in Q with minimum d(v) and add it to S
Relax(s1,s3)Relax(s1,s2)
25
s
s15
103
1
4
2s3
s2
s4
15 8
0
5
6
15
9
S = {s,s1}
Pick a vertex v in Q with minimum d(v) and add it to S
Relax(s1,s3)Relax(s1,s2)
26
s
s15
103
1
4
2s3
s2
s4
15 8
0
5
6
15
9
S = {s,s1}
Pick a vertex v in Q with minimum d(v) and add it to S
27
s
s15
103
1
4
2s3
s2
s4
15 8
0
5
6
15
9
S = {s,s1,s2}
Pick a vertex v in Q with minimum d(v) and add it to S
28
s
s15
103
1
4
2s3
s2
s4
15 8
0
5
6
15
9
S = {s,s1,s2}
Pick a vertex v in Q with minimum d(v) and add it to S
Relax(s2,s3)
29
s
s15
103
1
4
2s3
s2
s4
15 8
0
5
6
15
8
S = {s,s1,s2}
Pick a vertex v in Q with minimum d(v) and add it to S
Relax(s2,s3)
30
s
s15
103
1
4
2s3
s2
s4
15 8
0
5
6
15
8
S = {s,s1,s2}
Pick a vertex v in Q with minimum d(v) and add it to S
31
s
s15
103
1
4
2s3
s2
s4
15 8
0
5
6
15
8
S = {s,s1,s2,s3}
Pick a vertex v in Q with minimum d(v) and add it to S
32
s
s15
103
1
4
2s3
s2
s4
15 8
0
5
6
15
8
S = {s,s1,s2,s3,s4}
Pick a vertex v in Q with minimum d(v) and add it to S
33
s
s15
103
1
4
2s3
s2
s4
15 8
0
5
6
15
8
S = {s,s1,s2,s3,s4}
When Q = then the d() values are the distances from s
The π function gives the shortest path tree
34
s
s15
103
1
4
2s3
s2
s4
15 8
0
5
6
15
8
S = {s,s1,s2,s3,s4}
When Q = then the d() values are the distances from s
The π function gives the shortest path tree
35
Implementation of Dijkstra’s algorithm
• We need to find efficiently the vertex with minimum d() in Q
• We need to update d() values of vertices in Q
36
Required ADT
• Maintain items with keys subject to
• Insert(x,Q)• min(Q)• Deletemin(Q)• Decrease-key(x,Q,Δ)
37
Required ADT
• Insert(x,Q)• min(Q)• Deletemin(Q)• Decrease-key(x,Q,Δ): Can simulate
by Delete(x,Q), insert(x-Δ,Q)
38
• Insert(x,Q)• min(Q)• Deletemin(Q)• Decrease-key(x,Q,Δ): Can simulate
by Delete(x,Q), insert(x-Δ,Q)
How many times we do these operations ?
n = |V|
n
n
m = |E|
39
Do we know an algorithm for this ADT ?
• Insert(x,Q)• min(Q)• Deletemin(Q)• Decrease-key(x,Q,Δ): Can simulate
by Delete(x,Q), insert(x-Δ,Q)Yes! Use binary search trees, we had insert and delete and also min in the dictionary data type
40
Heap (min)
• Heap is A complete binary tree For any node v, both children’s keys
are larger than its key
Heap-ordered tree
23
7
17
3365
1924 2629
7940
41
• Representing a heap with an array Get the elements from top to
bottom, from left to right
Array Representation
23
7
17
3365
1924 2629
7 23 17 24 29 26 19 65 33 40 79
7940
Q
42
Array Representation
23
7
17
3365
1924 2629
7 23 17 24 29 26 19 65 33 40 79
7940
• Left(i): 2i+1• Right(i): 2i+2• Parent(i): (i-1)/2
Q
43
Find the minimum
23
7
17
3365
1924 2629
7 23 17 24 29 26 19 65 33 40 79
7940
• Return Q[0]
Q
44
Delete the minimum
23
7
17
3365
1924 2629
7 23 17 24 29 26 19 65 33 40 79
7940
Q
45
Delete the minimum
23 17
3365
1924 2629
23 17 24 29 26 19 65 33 40 79
7940
Q
46
Delete the minimum
23
79
17
3365
1924 2629
79 23 17 24 29 26 19 65 33 40
40
Q
47
Delete the minimum
23
17
79
3365
1924 2629
17 23 79 24 29 26 19 65 33 40
40
Q
48
Delete the minimum
23
17
19
3365
7924 2629
17 23 19 24 29 26 79 65 33 40
40
Q
49
Delete the minimum
23
17
19
3365
7924 2629
17 23 19 24 29 26 79 65 33 40
40
Q
Q[0] ← Q[size(Q)-1]
Heapify-down(Q,0)
size(Q) ← size(Q)-1
50
Heapify-down(Q,i)
Heapify-down(Q, i)
l ← left(i)
r ← right(i)
smallest ← i
if l < size(Q) and Q[l] < Q[smallest]
then smallest ← l
if r < size(Q) and Q[r] < Q[smallest]
then smallest ← r
if smallest > i then Q[i] ↔ Q[smallest]
Heapify-down(Q, smallest)
51
Inserting an item
23
17
19
3365
7924 2629
17 23 19 24 29 26 79 65 33 40
40
Q
Insert(15,Q)
52
Inserting an item
23
17
19
3365
7924 2629
17 23 19 24 29 26 79 65 33 40 15
40
Q
Insert(15,Q)Q[size(Q)] ← 15
15
Heapify-up(Q,size(Q))size(Q) ← size(Q) + 1
53
Inserting an item
23
17
19
3365
7924 2615
17 23 19 24 15 26 79 65 33 40 29
40
Q
29
54
Inserting an item
15
17
19
3365
7924 2623
17 15 19 24 23 26 79 65 33 40 29
40
Q
29
55
Inserting an item
17
15
19
3365
7924 2623
15 17 19 24 23 26 79 65 33 40 29
40
Q
29
56Q
Heapify-upH
eapify-up(A, i)
while i > 0 and A[i] < A[parent(i)]
do A[i] ↔ A[parent(i)]
i ← parent(i)
17
15
19
3365
7924 2623
40 29
15 17 19 24 23 26 79 65 33 40 29
57
Other operations
• Decrease-key(x,Q,Δ)• Delete(x,Q)
• Can implement them easily using heapify
Assume a pointer is given to element x (no
need to find!!
58
Heapsort (Williams, Floyd, 1964)
• Put the elements in an array• Make the array into a heap• Do a deletemin and put the
deleted element at the last position of the array
59
Put the elements in the heap
65
79
26
3323
2924 1519
79 65 26 24 19 15 29 23 33 40 7
740
Q
60
65
79
26
3323
2924 1519
79 65 26 24 19 15 29 23 33 40 7
740
Q
Make the elements into a heap
61
Make the elements into a heap
65
79
26
3323
2924 1519
79 65 26 24 19 15 29 23 33 40 7
740
Q
Heapify-down(Q,4)
62
65
79
26
3323
2924 157
79 65 26 24 7 15 29 23 33 40 19
1940
Q
Heapify-down(Q,4)
63
65
79
26
3323
2924 157
79 65 26 24 7 15 29 23 33 40 19
1940
Q
Heapify-down(Q,3)
64
65
79
26
3324
2923 157
79 65 26 23 7 15 29 24 33 40 19
1940
Q
Heapify-down(Q,3)
65
65
79
26
3324
2923 157
79 65 26 23 7 15 29 24 33 40 19
1940
Q
Heapify-down(Q,2)
66
65
79
15
3324
2923 267
79 65 15 23 7 26 29 24 33 40 19
1940
Q
Heapify-down(Q,2)
67
65
79
15
3324
2923 267
79 65 15 23 7 26 29 24 33 40 19
1940
Q
Heapify-down(Q,1)
68
7
79
15
3324
2923 2665
79 7 15 23 65 26 29 24 33 40 19
1940
Q
Heapify-down(Q,1)
69
7
79
15
3324
2923 2619
79 7 15 23 19 26 29 24 33 40 65
6540
Q
Heapify-down(Q,1)
70
7
79
15
3324
2923 2619
79 7 15 23 19 26 29 24 33 40 65
6540
Q
Heapify-down(Q,0)
71
79
7
15
3324
2923 2619
7 79 15 23 19 26 29 24 33 40 65
6540
Q
Heapify-down(Q,0)
72
19
7
15
3324
2923 2679
7 19 15 23 79 26 29 24 33 40 65
6540
Q
Heapify-down(Q,0)
73
19
7
15
3324
2923 2640
7 19 15 23 40 26 29 24 33 79 65
6579
Q
Heapify-down(Q,0)
74
23
7
15
3379
2924 2619
6540
We have at most n/2 nodes heapified at height 1
How much time it takes to build the heap this way ?
We have at most n/4 nodes heapified at height 2We have at most n/8 nodes heapified at height 3
1
1 2 3 ......... ( )2 4 8 2hn n n h
O O n O n
75
Summary
• We can build the heap in linear time (we already did this analysis)
• We still have to deletemin the elements one by one in order to sort that will take O(nlog(n))
76
Comparison to RB / 2-3
• We can build the heap in linear time (we already did this analysis)
• If we start with unsorted elements: Can get percentiles efficiently (e.g. 10 smallest)
• Constants are smaller than in RB and 2-3
• Great for sorting• Great for priority queue (can be done
also by RB)