COMP 250. Lecture 24. heaps 2. Nov. 3, 2017

Transcription

1 COMP 250 Lecture 24 heaps 2 Nov. 3, 207

2 RECALL: min Heap (definition) a e b f l u k m Complete binary tree with (unique) comparable elements, such that each node s element is less than its children s element(s). 2

3 Heap (array implementation) f c 2 3 m a e g j Not used d j d d d d

4 a e 2 3 b f l u k Not used m g n q w z a e b f l u k m g n q w z

5 parent = child / 2 left = 2*parent right = 2*parent + Heap index relations a e 2 3 b f l u k Not used m g n q w z

6 parent = child / 2 left = 2*parent right = 2*parent + Heap index relations a e 2 3 b f l u k Not used m g n q w z

7 parent = child / 2 left = 2*parent right = 2*parent + Heap index relations a e 2 3 b f l u k Not used m g n q w z

8 parent = child / 2 left = 2*parent right = 2*parent + Heap index relations a e 2 3 b f l u k Not used m g n q w z

9 ASIDE: an array data structure can be used for any binary tree. But this is uncommon and often inefficient. a e 2 3 b f u k m g z a e b f u k m g z

10 add(element) removemin() upheap downheap 0

11 add(element ){ size = size + // number of elements in heap heap[ size ] = element // assuming array // has room for another element i = size // the following is sometimes called "upheap" } while ( i > and heap[i] < heap[ i/2 ]){ swapelements( i, i/2 ) i = i/2 }

12 e.g. add( c ) a e 2 3 b f l u k Not used 8 m a e b f l u k m

13 e.g. add( c ) a e 2 3 b f l u k Not used m 8 9 c a e b f l u k m c

14 e.g. add( c ) a e 2 3 b c l u k Not used m 8 9 f a e b c l u k m f

15 e.g. add( c ) a 2 3 c b e l u k Not used m 8 9 f a c b e l u k m f

16 Given a list with size elements: buildheap(list){ } create new heap array // length > list.size for (k = 0; k < list.size; k++) add( list[k] ) // add to heap[ ] 6

17 You could write the buildheap algorithm slightly differently by putting all the list elements into the array at the beginning, and then `upheaping each one. 7

18 Best case of buildheap is? Suppose we want to add some elements to an empty heap: a e b c l u k m f How many swaps do we need to add each element? In the best case, 8

19 Best case of buildheap is Q(n) a e b c l u k m f How many swaps do we need to add each element? In the best case, the order of elements that we add is already a heap, and no swaps are necessary. 9

20 Worse case of buildheap? c f 2 3 m level 0 a e g d j d d d d j 2 3 How many swaps do we need to add the i-th element? 20

21 Worse case of buildheap? c f 2 3 m level 0 a e g d j d d d d j 2 3 How many swaps do we need to add the i-th element? Element i gets added to some level, such that: 2 level level + i < 2 2

22 Worse case of buildheap? c f 2 3 m level 0 a e g d j d d d d j level level + i < 2 level log 2 i < level + Thus, level = floor( log 2 i ) 22

23 Worse case of buildheap f Suppose there are i. n elements to add. d j a c 2 3 d e g m d d d j Worst case number of swaps needed to add node i. n t n = i= floor( log 2 i ) 23

24 2 log 2 i 8 floor( log 2 i ) i 24

25 2 log 2 i 8 n t n = i= floor( log 2 i ) 4 0 Area under the dashed curve is the total number of swaps (worst case) of buildheap i 25 n

26 log 2 n 2 8 t n n log 2 n i 26 n

27 log 2 n n log 2n t n n log 2 n i 27 n

28 Thus, worst case: buildheap is Θ(n log 2 n) Next lecture I will show you a Θ(n) algorithm. 28

29 add(element) removemin() upheap downheap 29

30 e.g. removemin() a 2 3 c b e l u k Not used m 8 9 f a c b e l u k m f

31 a f 2 3 c b e l u k Not used m 8 9 f c b e l u k m

32 b 2 3 c f e l u k Not used m 8 9 b c f e l u k m

33 removemin() Let heap[ ] be the array. Let size be the number of elements in the heap. removemin( ){ tmpelement = heap[] heap[] = heap[size] heap[size] = null size = size - downheap(, size) return tmpelement } // heap[0] not used. 33

34 removemin() Let heap[ ] be the array. Let size be the number of elements in the heap. removemin( ){ tmpelement = heap[] // heap[0] not used. heap[] = heap[size] heap[size] = null size = size - downheap(, size) // next slide return tmpelement } 34

35 downheap( startindex, maxindex ){ } i = startindex while (2*i <= maxindex){ // if there is a left child child = 2*i if child < size { // if there is a right sibling if (heap[child + ] < heap[child]) // if rightchild < leftchild? child = child + } if (heap[child] Find < heap[ the i smaller ]){ // child Do we (left need or right?) to swap with child? swapelements(i, child) i = child } } 35

36 downheap( startindex, maxindex ){ } i = startindex while (2*i <= maxindex){ // if there is a left child child = 2*i if child < size { // if there is a right sibling if (heap[child + ] < heap[child]) // if rightchild < leftchild? child = child + } if (heap[child] < heap[ i ]){ // Do we need to swap with child? swapelements(i, child) i = child } } 36

37 downheap( startindex, maxindex ){ i = startindex while (2*i <= maxindex){ // if there is a left child child = 2*i if child < size { // if there is a right sibling if (heap[child + ] < heap[child]) // if rightchild < leftchild? child = child + } if (heap[child] < heap[ i ]){ // Do we need to swap with child? swapelements(i, child) i = child } else return // otherwise we have an infinite loop. } } 37

38 Announcements Mycourses survey about MATH 240/235 and COMP 25 Update on final exam grading policy 38

39 Final Exam grading policy Multiple Choice with 50 questions Four choices on each question No penalty for incorrect answers (so don t leave any question blank) Grade out of 50 = max(0, /5 * raw number correct) 39

40 Raw number correct for pure guessing? (binomial distribution, n=50, p=.25) Hey, me and all my buddies averaged 25% raw scores on the final. 40