226 COS Lecture 5: Priority Queues Abstract data types client interface implementation Priority queue ADT insert remove the largest HEAPS and Heapsort
ADTs and algorithms PERFORMANCE MATTERS ADT allows us to substitute better algorithms without changing any client code Running time depends on implementation client usage Might need different implementations for different clients GOALS general-purpose ADT useful for many clients efficient implementation of all ADT functions ADTs provide levels of abstraction allowing us to build algorithms for increasingly complicated problems Ex: linked list -> stack -> quicksort
BINOMIAL QUEUES
5.1
5.3
Abstract data types Separate INTERFACE and IMPLEMENTATION easier maintainence of large programs build layers of abstraction reuse software elementary example: pushdown stack INTERFACE: description of data type, basic operations CLIENT: program using operations defined in interface IMPLEMENTATION: actual code implementing operations Client can't know details of implementation (many implementations to choose from) Implementation can't know details of client needs (many clients use the same implementation) Modern programming languages support ADTs C++, Modula-3, Oberon, Java (C)
5.2
Priority queue ADT Records with keys (priorities) Two basic operations INSERT DELETE LARGEST generic operations common to many ADTs create test if empty destroy (often ignored if not harmful) Example applications simulation numerical computation compression algorithms graph-searching algorithms
5.4
Priority queue interface INTERFACE for basic operations
. . . . void PQinit(); void PQinsert(Item); Item PQdelmax(); int PQempty();
Unordered-array PQ implementation
static Item *pq; static int N; PQinsert(Item v) { pq[N++] = v; } Item PQdelmax() { int j, max = 0; for (j = 1; j < N; j++) if (less(pq[max], pq[j])) max = j; exch(pq[max], pq[N]); return pq[--N]; } void PQinit(int maxN) { pq = malloc(maxN*sizeof(Item)); N = 0; } int PQempty() { return N == 0; }
5.5 5.7
Should also specify constraints and error conditions Other useful operations delete a specified item change an item's priority merge together two PQs (stay tuned)
Sample PQ client Find the M SMALLEST of N items (typical vals: M=100, N=1000000)
PQinit(); for (k = 0; k < M; k++) PQinsert(nextItem()); for (k = M; k < N; k++) { PQinsert(nextItem()); t = PQdelmax(); } for (k = 0; k < M; k++) a[k] = PQdelmax(());
Other PQ implementations Elementary ordered array unordered linked list ordered linked list Advanced heap binomial queue
Time bounds for standard implementations: space proportional to M brute-force: N M best: N lg M best offline: N (with select, see lecture 3)
5.6
5.8
Client/Interface/Implementation INTERFACE define data types declare functions in C, use ".h" file (no executable code) CLIENT: include ".h" file call functions IMPLEMENTATION: include ".h" file give code for functions Client and implementation can be compiled at different times, then function calls LINKED to their implementations Details: Sedgewick, Chapter 4; COS 217 Modular programming
5.9
First-class PQ ADT
. . . . . . . . . typedef struct pq* PQ; typedef struct PQnode* PQlink; PQ PQinit(); int PQempty(PQ); PQlink PQinsert(PQ, Item); Item PQdelmax(PQ); void PQchange(PQ, PQlink, Item); void PQdelete(PQ, PQlink); PQ PQjoin(PQ, PQ);
PQ and PQlink are pointers to structures to be specified in the implementation More info: section 4.8 in Sedgewick; lecture 7
5.11
Priority queue ADT (continued) Other useful operations construct a PQ from N items return the value of the largest delete a specified item change an item's priority merge together two PQs Interface more complicated need HANDLES for records need HANDLES for priority queues where's the data? (client, implementation, or both?)
PQ implementations cost summary Worst-case per-operation time as a function of PQ size
. . ordered array list unordered array list heap binomial queue best in
5.10
insert N N 1 1
delete find change max delete max key 1 1 N N lg N lg N N 1 1 1 lg N lg N 1 1 N N 1 lg N N N 1 1 lg N lg N
join N N N 1 N lg N
lg N lg N
theory
1
lg N
lg N
1
1
1
5.12
PQ data structures HEAP lg N for all operations BINOMIAL QUEUE lg N for all operations constant (amortized) for most basis for near-optimal slgs Algorithm design success story: nearly optimal worst-case cost simple (but ingenious!) algorithms costs even lower in practice
Heap Array representation of heap-ordered binary tree root in a[1] children of 1 in a[2] and a[3] children of i in a[2i] and a[2i+1] parent of i in a[i/2] No explicit links needed for tree
. . 0 1 X 2 T 3 O 4 G 5 S 6 M 7 N 8 A 9 10 11 12 E R A I
5.13
5.15
Heap-ordered complete binary trees COMPLETE BINARY TREE: leaves on two levels, on left at bottom level HEAP-ORDERED: parent larger than both children therefore, largest at root can define for any tree, not just complete
1 2 4 8
Promotion (bubbling up in a heap) Change key in node at the bottom the of heap To restore heap condition: exchange with parent if necessary
X S P R E O A I M N
X
3
G
T
5
O
7
A
T
G
9
S
11
6
M
N
X
A
E
10
R
A
12
I
T
G A
5.14
P
S
E
O A I M
N
R
5.16
Promotion implementation Peter principle nodes rise to level of incompentence Node k's parent in heap is k/2
fixUp(Item a[], int k) { while (k > 1 && less(a[k/2], a[k])) { exch(a[k], a[k/2]); k = k/2; } }
Demotion implementation "Power struggle" principle better subordinate is promoted Node k's children in heap are 2k and 2k+1
fixDown(Item a[], int k, int N) { int j; while (2*k <= N) { j = 2*k; if (j < N && less(a[j], a[j+1])) j++; if (!less(a[k], a[j])) break; exch(a[k], a[j]); k = j; } }
5.17
5.19
Demotion (sifting down in a heap) Change key in node at the top of the heap To restore heap condition: exchange with larger child if necessary
PQ implementation with heaps PQinsert: add node at bottom, bubble up PQdelmax: exch root with node at bottom, sift down
static Item pq[maxPQsize+1]; static int N; void PQinit(int maxN)
O
T G A E R S A I P M X N
{ pq = malloc(maxN*sizeof(Item)); N = 0; } int PQempty() { return N == 0; } void PQinsert(Item v) { pq[++N] = v; fixUp(pq, N); }
X
T G A E R S A I
P O
M N
Item PQdelmax() { exch(pq[1], pq[N]); fixDown(pq, 1, N-1); return pq[N--];
5.18
}
5.20
Constructing a heap (top-down)
Heapsort Abandon ADT concept to save space Faster to construct heap backwards
#define pq(A) a[l-1+A]
T
A
A
S R
O
I
S
S
T O R I
void heapsort(Item a[], int l, int r)
N
A
A
{ int k, N = r-l+1; for (k = N/2; k >= 1; k--) fixDown(&pq(0), k, N);
T S A S O R I N
O
G A
while (N > 1) { exch(pq(1), pq(N));
S
T O A S G R I O N
R A
fixDown(&pq(0), 1, --N); } }
E X
T S
A O
T
G A E
O
S R
I
N
R
Widely used sorting method inplace, guaranteed NlgN time
5.23
Sorting down a heap
X T G A E R S A I O M L P N E A G E E M L I
Bottom-up heap construction
G
O N A
A
E A
E
A S O T E X A M P I L S A O T E X A M S N I L E G R E A O S N I L E G A O X E T A M P I L N E
T S
G A E E P M N M L A G E L
N I E
A O
E A A
G
R
A I
E
R
N
E G
R
P
X T
A M
P
R
S R
G A P
M L
N M A G I O
E
A
L E
E A I
E
E
A
A
S
A
A
X
P
X P T N I L E G R E A S A M O I L P N E
P
X
X
N R E G E
T
N R E G E
R M
G A E E L A I O P N
L G A
E E I A A
A
G
R E T
O
A M I L
T S
A M
O I L
S A
A M
O
P
M G A E E L A
I O I
N A G E
E A
A
5.22 5.24
Binomial queues Support ALL PQ operations in lgN steps Heaps have slow merge Def: In a LEFT HEAP-ORDERED tree, each node is larger than all nodes in left subtree Def: A POWER-OF-2 TREE is a binary tree left subtree of root complete right subtree empty (therefore, 2^n nodes) Def: A BINOMIAL QUEUE of size N is of left heap-ordered power-of-2 trees one for each 1 bit in binary rep. of N
5.25
Joining power-of-2 heaps Constant-time operation larger of two roots at top left subtree to right subtree of other root result is left-heap-ordered if inputs a...