Comparisons. Heaps. Heaps. Heaps. Sorting Revisited. Heaps. So far we talked about two algorithms to sort an array of numbers

Transcription

1 So far we have studied: Comparisons Tree is completely filled on all levels except possibly the lowest, which is filled from the left up to a point Insertion Sort Merge Sort Worst case Θ(n ) Θ(nlgn) Best case Θ(n) Θ(nlgn) The book calls them nearly complete binary trees; can think of unfilled slots as null pointers Sorting Revisited So far we talked about two algorithms to sort an array of numbers What is the advantage of merge sort? Answer: O(n lg n) worst-case running time What is the advantage of insertion sort? Sorts in place (only a constant number of elements of the input array are ever stored outside the array) Fast with small input size (so when array nearly sorted, runs fast in practice) Next: ort Combines advantages of both previous algorithms In practice, heaps are usually implemented as arrays: A = = Array A representing a heap is an object with two attributes: length[a] = the number of elements in the array, and heap-size[a] = the number of elements in the heap stored within array A. Clearly, heap-size[a] length[a] A heap can be seen as a complete binary tree: What makes a binary tree complete? Is the example above complete? To represent a complete binary tree as an array: The root node is A[] Node i is A[i] The parent of node i is A[i/] (note: integer divide) The left child of node i is A[i] The right child of node i is A[i + ] A = =

2 Referencing Heap Elements The root of the tree is A[], and given the index i of a node, the indices of its parent PARENT(i), left child LEFT(i), and right child RIGHT(i) can be computed simply: PARENT(i) { return i/ } LEFT(i) { return *i } RIGHT(i) { return *i + } Basic Heap Procedures The HEAPIFY procedure, which runs in O(lg n) time, is the key to maintaining the heap property. The BUILD-HEAP procedure, which runs in linear time, produces a heap from an unordered input array. The HEAPSORT procedure, which runs in O(n lg n) time, sorts an array in place The Heap Property also satisfy the heap property: A[Parent(i)] A[i] for all nodes i > In other words, the value of a node is at most the value of its parent Largest element in a heap stored at the root Definitions: The height of a node in the tree = the number of edges on the longest downward path to a leaf The height of a tree = the height of its root Heap Operations: Heapify() Heapify(): maintain the heap property Given: a node i in the heap with children l and r Given: two subtrees rooted at l and r, assumed to be heaps Problem: The subtree rooted at i may violate the heap property Action: let the value of the parent node float down so subtree at i satisfies the heap property Heap Height Since a heap of n elements is based on a complete binary tree, its height is Θ(lg n) (in other words a binary tree of height h has at most h leaves) This is nice: turns out that basic heap operations take at most time proportional to the height of the heap Heap Operations: Heapify() HEAPIFY(A, i) l LEFT(i) r RIGHT(i) 3 if l heap-size[a] and A[l] > A[i] 4 then largest l 5 else largest i 6 if r heap-size[a] and A[r] > A[largest] 7 then largest r 8 if largest i 9 then exchange A[i] A[largest] 0 HEAPIFY(A, largest)

3 Heap Operations: Heapify() At each step, the largest of the elements A[i], A[LEFT(i)], and A[RIGHT(i)] is determined, and its index is stored in largest. If A[i] is largest, then the subtree rooted at node i is a heap and the procedure terminates. Otherwise, one of the two children has the largest element, and A[i] is swapped with A[largest], which causes node i and its children to satisfy the heap property. The node indexed by largest, however, now has the original value A[i], and thus the subtree rooted at largest may violate the max-heap property. Consequently, HEAPIFY must be called recursively on that subtree A = A = A = A = A =

4 A = A = Analyzing Heapify() A = Fixing up relationships between i, l, and r takes Θ() time (constant time) If the heap at i has n elements, how many elements can the subtrees at l or r have? Answer: n/3 (worst case: last row / full) So time taken by Heapify() is given by T(n) T(n/3) + Θ() Analyzing Heapify() A = So we have T(n) T(n/3) + Θ() By case of the Master Theorem, T(n) = O(lg n) Alternatively, we can characterize the running time of HEAPIFY on a node of height h as O(h). 4

5 Heap Operations: BuildHeap() We can build a heap in a bottom-up manner by running Heapify() on successive subarrays Fact: for array of length n, all elements in range A[ n/ +.. n] are all leaves of the tree and so each is a -element heap So: Go backwards through the array from n/ to, calling Heapify() on each node. Order of processing guarantees that the children of node i are heaps when i is processed BUILD-HEAP(A) Produces a heap from an unordered input array heap-size[a] length[a] for i length[a]/ downto 3 do HEAPIFY(A, i) Build-Heap:Worked Example The operation of BUILD-HEAP, showing the data structure before the call to HEAPIFY in line 3 of BUILD-HEAP. (a)a 0-element input array A and the binary tree it represents. The figure shows that the loop index i refers to node 5 before the call HEAPIFY(A, i). (b) The data structure that results. The loop index i for the next iteration refers to node 4. (c)-(e) Subsequent iterations of the for loop in BUILD-HEAP. Observe that whenever HEAPIFY is called on a node, the two subtrees of that node are both heaps. (f) The heap after BUILD-HEAP finishes. BuildHeap() Example Work through example A = {4,, 3,,, 9, 0, 4, 8, 7} Analyzing BuildHeap() Each call to Heapify() takes O(lg n) time There are O(n) such calls (specifically, n/ ) Thus the running time is O(n lg n) Is this a correct asymptotic upper bound? Is this an asymptotically tight bound? A tighter bound is O(n) How can we prove this? 5

6 Analyzing BuildHeap(): Tight Example: ort To Heapify() a subtree takes O(h) time where h is the height of the subtree h = O(lg m), m = # nodes in subtree The height of most subtrees is small Fact: an n-element heap has at most n/ h+ nodes of height h CLR 7.3 uses this fact to prove that BuildHeap() takes O(n) time ort Given BuildHeap(), an in-place sorting algorithm is easily constructed: Maximum element is at A[] Discard by swapping with element at A[n] Decrement heap_size[a] A[n] now contains correct value Restore heap property at A[] by calling Heapify() Repeat, always swapping A[] for A[heap_size(A)] Example: ort The operation of HEAPSORT: (a) The max-heap data structure just after it has been built by BUILD-HEAP. (b)-(j) The max-heap just after each call of HEAPIFY in line 5. The value of i at that time is shown. Only lightly shaded nodes remain in the heap. (k) The resulting sorted array A. HEAPSORT(A) ort BUILD-HEAP(A) for i length[a] downto 3 do exchange A[] A[i] 4 heap-size[a] heap-size[a] - 5 HEAPIFY(A, ) Analyzing ort The call to BuildHeap() takes O(n) time Each of the n - calls to Heapify() takes O(lg n) time Thus the total time taken by HeapSort() = O(n) + (n - ) O(lg n) = O(n) + O(n lg n) = O(n lg n) 6

7 Application: Priority Queues The heap data structure itself has enormous utility. One of the most popular applications of a heap: its use as an efficient priority queue. A priority queue is a data structure for maintaining a set S of elements, each with an associated value called a key. One application of max-priority queues is to schedule jobs on a shared computer. The priority queue keeps track of the jobs to be performed and their relative priorities. 7