CS221: Algorithms and Data Structures. Priority Queues and Heaps. Alan J. Hu (Borrowing slides from Steve Wolfman)

Transcription

1 CS: Algorthms and Data Structures Prorty Queues and Heaps Alan J. Hu (Borrowng sldes from Steve Wolfman)

2 Learnng Goals After ths unt, you should be able to: Provde examples of approprate applcatons for prorty queues and heaps Manpulate data n heaps Descrbe and apply the Heapfy algorthm, and analyze ts complexty

3 Today s Outlne Trees, Brefly Prorty Queue ADT Heaps Implementng Prorty Queue ADT Focus on Create: Heapfy Bref ntroducton to d-heaps 3

4 Tree Termnology root: leaf: chld: parent: sblng: ancestor: descendent: subtree: D B E A F H C G I J K L M N 4

5 Tree Termnology Reference root: the sngle node wth no parent leaf: a node wth no chldren chld: a node ponted to by me B parent: the node that ponts to me sblng: another chld of my parent D E ancestor: my parent or my parent s ancestor descendent: my chld or my chld s descendent subtree: a node and ts descendents A F H C G I We sometmes use degenerate versons J K L M N of these defntons that allow NULL as the empty tree. (Ths can be very handy for recursve base cases!) 5

6 More Tree Termnology depth: # of edges along path from root to node depth of H? B A C D E F G H I J K L M N 6

7 More Tree Termnology heght: # of edges along longest path from node to leaf or, for whole tree, from root to leaf heght of tree? B A C D E F G H I J K L M N 7

8 More Tree Termnology degree: # of chldren of a node degree of B? B A C D E F G H I J K L M N 8

9 More Tree Termnology branchng factor: maxmum degree of any node n the tree for bnary trees, our usual concern; 5 for ths werd tree D B E A F C G H I J K L M N 9

10 One More Tree Termnology Slde bnary: branchng factor of (each chld has at most chldren) A n-ary: branchng factor of n B C complete: packed bnary tree; as many nodes as possble for ts heght H D I J E F G 0 nearly complete: complete plus some nodes on the left at the bottom

11 Trees and (Structural) Recurson A tree s ether: the empty tree a root node and an ordered lst of subtrees Trees are a recursvely defned structure, so t makes sense to operate on them recursvely.

12 Today s Outlne Trees, Brefly Prorty Queue ADT Heaps Implementng Prorty Queue ADT Focus on Create: Heapfy Bref ntroducton to d-heaps

13 Back to Queues Some applcatons orderng CPU jobs smulatng events pckng the next search ste Problems? short jobs should go frst earlest (smulated tme) events should go frst most promsng stes should be searched frst 3

14 Prorty Queue ADT Prorty Queue operatons create destroy nsert deletemn sempty G(9) nsert F(7) E(5) D(00) A(4) B(6) deletemn Prorty Queue property: for two elements n the queue, x and y, f x has a lower prorty value than y, x wll be deleted before y C(3) 4

15 Applcatons of the Prorty Q Hold jobs for a prnter n order of length Store packets on network routers n order of urgency Smulate events Select symbols for compresson Sort numbers Anythng greedy: an algorthm that makes the locally best choce at each step 5

16 Naïve Prorty Q Data Structures Unsorted lst: nsert: deletemn: Sorted lst: nsert: deletemn: a. O(lg n) b. O(n) c. O(n lg n) d. O(n ) e. Somethng else 6

17 Today s Outlne Trees, Brefly Prorty Queue ADT Heaps Implementng Prorty Queue ADT Focus on Create: Heapfy Bref ntroducton to d-heaps 7

18 Bnary Heap Prorty Q Data Structure Heap-order property parent s key s less than or equal to chldren s keys result: mnmum s always at the top Structure property nearly complete tree result: depth s always O(log n); next open locaton always known 7 Look! Invarants! WARNING: ths has NO SIMILARITY to the heap you hear about 8 when people say objects you create wth new go on the heap.

19 Nfty Storage Trck Calculatons: chld: parent: root: next free:

20 (Asde: Steve numbers from.) Calculatons: chld: parent: root: next free: Steve lke to just skp usng entry 0 n the array, so the root s at ndex. 0 For a bnary heap, ths makes the calculatons slghtly shorter.

21 DeleteMn pqueue.deletemn()? Invarants volated! DOOOM!!!

22 Percolate Down ? ? ?

23 Fnally

24 DeleteMn Code Object deletemn() { assert(!sempty()); returnval Heap[0]; sze--; newpos percolatedown(0, Heap[sze]); Heap[newPos] Heap[sze]; return returnval; } runtme: nt percolatedown(nt hole, Object val) { whle (*hole+ < sze) { left *hole + ; rght left + ; f (rght < sze && Heap[rght] < Heap[left]) target rght; else target left; } f (Heap[target] < val) { Heap[hole] Heap[target]; hole target; } else break; } return hole; 4

25 Insert pqueue.nsert(3) Invarant volated! What wll we do? 5

26 Percolate Up

27 Insert Code vod nsert(object o) { assert(!sfull()); newpos percolateup(sze,o); sze++; Heap[newPos] o; } nt percolateup(nt hole, Object val) { whle (hole > 0 && val < Heap[(hole-)/]) Heap[hole] Heap[(hole-)/]; hole (hole-)/; } return hole; } runtme: 7

28 Today s Outlne Trees, Brefly Prorty Queue ADT Heaps Implementng Prorty Queue ADT Focus on Create: Heapfy Bref ntroducton to d-heaps 8

29 Closer Look at Creatng Heaps To create a heap gven a lst of tems: Create an empty heap. For each tem: nsert nto heap. Tme complexty? a. O(lg n) b. O(n) 9, 4, 8,, 7, 3 c. O(n lg n) 5 d. O(n ) e. None of these 0 9 3

30 A Better BuldHeap Floyd s Method. Thank you, Floyd pretend t s a heap and fx the heap-order property! Invarant volated! Where can the order nvarant be volated n general? a. Anywhere b. Non-leaves c. Non-roots

31 Alan s Asde: I don t really lke the way Steve explans ths. Heaps are recursve (mostly, except for structure): A sngle node s a heap. If parent value less than ts chld(ren), and chld(ren) are heaps (except for nearly complete property). Thnk of enforcng the heap nvarant from the bottom up! Base Case: All nodes wth no chldren are heaps already. Inductve Case: My chldren are heaps. Percolate my value down, and that makes me a heap, too.

32 Buld(ths)Heap

33 Fnally runtme: 33

34 Buld(any)Heap Ths s as many volatons as we can get. How do we fx them? Let s play colourng games! 34

35 Buld(any)Heap Alan s Asde: I lke to thnk of ths nstead as chargng edges n the tree for the cost of the moves. We can work out a scheme where each edge pays only once. (A - correspondence!) 35

36 Buld(any)Heap Alan s Asde: The proof that ths always works s nductve. The nductve step s that both of my subtrees have an uncharged path (rghtmost) to the leaves. I charge my cost to my left chld, and my rght chld provdes the rghtmost, uncharged path that I offer to my parent. 36

37 Alan s Asde Alternatvely, we can do ths wth algebra. Consder a complete heap: As we do percolate-down on bottom row, the cost s 0, each. There are roughly n/ nodes on bottom row. On next row up, the cost s, each. There are roughly n/4 nodes on second row. On the kth row up, the cost s k- tmes n/(^k) nodes on that row. logn n n n Therefore, run tme s n ( ) + 0 0

38 Alan s Asde The last sum s trcky Thnk of the s as +; the 3s, as ++; etc. Now, add up a layer of s for the whole tree. Then, add up a layer of s for the part of the tree where the cost was or more. Then, add up a layer of s for the part of the tree where the cost was 3 or more. Etc.

39 Alan s Asde

40 Alan s Asde j j j j j j

41 Steve s Verson of Alan s Asde ( ) S S

42 Today s Outlne Trees, Brefly Prorty Queue ADT Heaps Implementng Prorty Queue ADT Focus on Create: Heapfy Bref ntroducton to d-heaps 4

43 Thnkng about Bnary Heaps Observatons fndng a chld/parent ndex s a multply/dvde by two operatons jump wdely through the heap deletemns look at all (two) chldren of some nodes nserts only care about parents of some nodes nserts are at least as common as deletemns Realtes dvson and multplcaton by powers of two are fast lookng at one new pece of data sucks n a cache lne wth huge data sets, dsk accesses domnate 43

44 Soluton: d-heaps Nodes have (up to) d chldren Stll representable by array Good choces for d: optmze (non-asymptotc) performance based on rato of nserts/removes make d a power of two for effcency ft one set of chldren n a cache lne ft one set of chldren on a memory page/dsk block d-heap mnemonc: d s for degree! 44

45 d-heap calculatons Calculatons n terms of d: chld: parent: 3 7 root: next free: Alan s Asde: Easer to work pattern f you count from zero! d-heap mnemonc: d s for degree! 45

46 d-heap calculatons Calculatons n terms of d: chld: d*+ through d*+d parent: floor((-)/d) 3 7 root: next free: sze Alan s Asde: Easer to work pattern f you count from zero! d-heap mnemonc: d s for degree! 46

47 (Steve s d-heap calculatons) Calculatons n terms of d: chld: parent: 3 7 root: next free: d-heap mnemonc: d s for degree! 47

48 (Steve s d-heap calculatons) Calculatons n terms of d: chld: (-)*d+ through *d+ parent: floor((-)/d) root: next free: sze d-heap mnemonc: d s for degree! 48

49 Rest of Today s Learnng Goals Get comfortable wth C++ ponters, understand the * and & operators. Draw dagrams to help understand code that manpulates ponters. 49

50 C++ Reference Parameters & n a formal parameter makes the parameter another name for the argument that was passed n! (Ths s a totally dfferent meanng of & from the address of operator (and also totally dfferent from btwse-and).) It s not a copy of the value of the argument, the way normal parameter passng works.

51 C++ Reference Parameters vod swap(nt x, nt y) { nt t x; x y; y t; } nt a0; nt b; swap(a,b); cout << a <<, << b; vod swap(nt &x, nt &y) { nt t x; x y; y t; } nt a0; nt b; swap(a,b); cout << a <<, << b;

52 C++ Reference Parameters vod swap(nt x, nt y) { nt t x; x y; y t; } nt a0; nt b; swap(a,b); cout << a <<, << b; vod swap(nt &x, nt &y) { nt t x; x y; y t; } nt a0; nt b; swap(a,b); cout << a <<, << b;

53 Old-School C (and C++) vod swap(nt *x, nt *y) { nt *t x; x y; y t; } nt a0; nt b; swap(a,b); cout << a <<, << b; vod swap(nt *x, nt *y) { nt t *x; *x *y; *y t; } nt a0; nt b; swap(a,b); cout << a <<, << b;

54 Old-School C (and C++) vod swap(nt *x, nt *y) { nt *t x; x y; y t; } nt a0; nt b; swap(a,b); cout << a <<, << b; vod swap(nt *x, nt *y) { nt t *x; *x *y; *y t; } nt a0; nt b; swap(a,b); cout << a <<, << b;

55 Old-School C (and C++) vod swap(nt *x, nt *y) { nt t *x; *x *y; *y t; } nt a0; nt b; swap(&a,&b); cout << a <<, << b; vod swap(nt *x, nt *y) { nt t *x; *x *y; *y t; } nt a0; nt b; swap(a,b); cout << a <<, << b;

56 Old-School C (and C++) vod swap(nt *x, nt *y) { nt t *x; *x *y; *y t; } nt a0; nt b; swap(&a,&b); cout << a <<, << b; vod swap(nt *x, nt *y) { nt t *x; *x *y; *y t; } nt a0; nt b; swap(a,b); cout << a <<, << b;