data structures and algorithms lecture 4

Transcription

1 data structures and algorithms lecture 4

2 overview heaps heapsort heap sort: more priority queues material

3 use of max-heaps as a data structure for heapsort as a data structure for storing a collection of elements with keys then we wish to be able to add an element with some key know what is the max key remove the element with a max key

4 maxheapify: recall pseudo code Algorithm maxheapify(a, i): l := left(i) r := right(i) if l A.heap-size and A[l] > A[i] then largest := l else largest := i if r A.heap-size and A[r] > A[largest] then largest := r if largest i then swap(a[i], A[largest]) maxheapify(a, largest)

5 maxheapify: time complexity determined by height (1) with h the height of the heap: T (h) = T (h 1) + 1 if h > 0 gives T (h) O(h) then use h Θ(log n) gives T (n) O(log n) (2) with n the number of nodes of the heap: T (n) = T ( 2 3n) + 1 if n > 1 gives T (n) O(log n) because in the worst case the bottom level is exactly half full

6 maxheapify: intuition of correctness induction on the height of node i if the height is 0, then immediate if the height is > 0, then two cases case largest = i: immediate case largest = l (and equivalent for largest = r): use induction

7 how to build a heap? (1) given n keys, insert them one by one one insertion in O(log n) (not yet discussed) so totally in O(n log n) (2) using the bottom-up heap construction then in O(n) the latter is used in the heapsort algorithm

8 bottom-up heap construction: idea consider array as proto-heap assume that for index i both immediate subtrees, at index 2i and at index 2i + 1, are already heaps use maxheapify at index i

9 building a heap: example build a heap from the following input consisting of = 15 numbers:

10 building a heap: pseudo-code Algorithm buildmaxheap(h): H.heap-size := H.length for i = H.length/2 downto 1 do maxheapify(h, i)

11 buildmaxheap: correctness use the following loop invariant: at the start of the for-loop each node i + 1,..., n is the root of a max-heap init: for i = n 2 the nodes i + 1,..., n are leaves loop: children are max-heaps by induction use correctness of maxheapify end: for i = 0 the invariant gives correctness of the output

12 buildmaxheap: complexity rough estimation: for each of the n 2 internal nodes of the heap we do maxheapify which is in O(h) so buildmaxheap in O(n log n) more precise estimation: for every height j in 0,..., log n for each of the at most n 2 j+1 nodes of height j we do maxheapify which is in O(j) so (!) buildmaxheap is in O(n)

13 buildmaxheap: alternative algorithm? from 1 to n 2? try [1, 3, 2, 4, 5, 6, 7] with i = 1, 2, 3

14 overview heaps heapsort heap sort: more priority queues material

15 heapsort: idea first part: turn the input-array into a max-heap second part: swap the key on the root with the key on the last node exclude the last node from the heap reconstruct the heap

16 heapsort: pseudo-code H[1... n] an array of integers directly after building the heap: H.heap-size = H.length Algorithm heapsort(h): buildmaxheap(h) for i = H.length downto 2 do swap H[1] and H[i] H.heap-size := H.heap-size 1 maxheapify(h, 1)

17 example heapsort [16, 14, 10, 8, 7, 9, 3, 2, 4, 1]

18 heapsort: properties why is heapsort correct? what is the worst-case running time of heapsort?

19 heapsort: properties why is heapsort correct? what is the worst-case running time of heapsort? buildmaxheap in O(n)

20 heapsort: properties why is heapsort correct? what is the worst-case running time of heapsort? buildmaxheap in O(n) n 1 calls of maxheapify with every call in O(log n)

21 heapsort: properties why is heapsort correct? what is the worst-case running time of heapsort? buildmaxheap in O(n) n 1 calls of maxheapify with every call in O(log n) hence the worst-case running time of heapsort is in O(n log n) why is heapsort in-place? what is a best-case input?

22 heapsort: inventor J.W.J. Williams in 1964

23 sorting used in many different settings also artistic impressions, even dance puzzle: can we sort 5 elements in 7 comparisons?

24 inspired by heapsort: smooth sort

25 smooth sort: inventor Edsger W. Dijkstra Turing Award 1972

26 overview heaps heapsort heap sort: more priority queues material

27 maximum: pseudo-code H a max-heap; return the max Algorithm heapmaximum(h): return H[1]

28 remove: pseudo-code H max-heap; remove and return maximum; error omitted Algorithm extractmax(h): max := H[1] H[1] := H[H.heap-size] H.heap-size := H.heap-size 1 maxheapify(h, 1) return max running time?

29 remove: pseudo-code H max-heap; remove and return maximum; error omitted Algorithm extractmax(h): max := H[1] H[1] := H[H.heap-size] H.heap-size := H.heap-size 1 maxheapify(h, 1) return max running time? in O(log n)

30 insert for max-priority queue: pseudo-code H a max-heap; insert key k; bubble upwards Algorithm insert(h, k): H.heap-size := H.heap-size + 1 H[H.heap-size] := HeapIncreaseKey(H, H.heap-size, k) Algorithm HeapIncreaseKey(H, i, k): if k < H[i] then return error H[i] := k while i > 0 and H[parent(i)] < H[i] do swap(h[parent(i)], H[i]) i := parent(i)

31 example: insert add key 19 to the max-heap [15, 13, 9, 5, 12, 8, 7, 4, 1, 6]

32 priority queue data type for maintaining a set access via keys queue where most important element is served first most important: minimum key or maximum key

33 priority queue: abstract data type insert(q, x) inserts element x in the (max- or min-)priority queue Q for max-priority queue: extractmax(q) removes element with maximum key maximum(q) returns (but does not remove) element with max key

34 priority queue: implementation use a heap max-heap for max-priority queue min-heap for min-priority queue

35 priority queue operations: running time insert in O(log n) remove in O(log n) maximum or mimimum in O(1)

36 questions about algorithms give the intuition of the algorithm give the pseudo-code for the algorithm apply the algorithm adapt the algorithm analyse correctness of the algorithm analyse (worst-case) time complexity of the algorithm

37 overview heaps heapsort heap sort: more priority queues material

38 material Book Chapter 6 further reading: smooth sort further reading: sorting wikipedia