The Heap Data Structure

Transcription

1 The Heap Data Structure Def: A heap is a nearly complete binary tree with the following two properties: Structural property: all levels are full, except possibly the last one, which is filled from left to right Order (heap) property: for any node x, Parent(x) x From the heap property, it follows that: 4 The root is the maximum element of the heap! 5 2 Heap 5

2 Array Representation of Heaps A heap can be stored as an array A. Root of tree is A[] Left child of A[i] = A[2i] Right child of A[i] = A[2i + ] Parent of A[i] = A[ i/2 ] Heapsize[A] length[a] The elements in the subarray A[( n/2 +).. n] are leaves

3 Heap Types Max-heaps (largest element at root), have the max-heap property: for all nodes i, excluding the root: A[PARENT(i)] A[i] Min-heaps (smallest element at root), have the min-heap property: for all nodes i, excluding the root: A[PARENT(i)] A[i]

4 Adding/Deleting Nodes New nodes are always inserted at the bottom level (left to right) Nodes are deleted from the bottom level (right to left)

5 Operations on Heaps Maintain/Restore the max-heap property MAX-HEAPIFY Create a max-heap from an unordered array BUILD-MAX-HEAP Sort an array in place HEAPSORT Priority queues 9

6 Maintaining the Heap Property MAX-HEAPIFY Suppose a node i is smaller than a child and Left and Right subtrees of i are max-heaps How do you fix it? To eliminate the violation: Exchange node i with the larger child Move down the tree Continue until node is not smaller than children MAX-HEAPIFY 0

7 Example MAX-HEAPIFY(A, 2, 0) A[2] A[4] A[2] violates the heap property A[4] violates the heap property A[4] A[9] Heap property restored

8 Maintaining the Heap Property Assumptions: Left and Right subtrees of i are max-heaps A[i] may be smaller than its children Alg: MAX-HEAPIFY(A, i, n). l LEFT(i) 2. r RIGHT(i) 3. if l n and A[l] > A[i] 4. then largest l 5. else largest i 6. if r n and A[r] > A[largest]. then largest r. if largest i 9. then exchange A[i] A[largest] 0. MAX-HEAPIFY(A, largest, n)

9 MAX-HEAPIFY Running Time It traces a path from the root to a leaf (longest path length h) At each level, it makes two comparisons Total number of comparisons = 2h Running Time of MAX-HEAPIFY = O(2h) = O(lgn)

10 Building a Heap Convert an array A[ n] into a max-heap (n = length[a]) The elements in the subarray A[( n/2 +).. n] are leaves Apply MAX-HEAPIFY on elements between and n/2 (bottom up) Alg: BUILD-MAX-HEAP(A). n = length[a] 2. for i n/2 downto 3. do MAX-HEAPIFY(A, i, n) A:

11 Example: A i = 5 i = 4 i = i = 2 i =

12 Running Time of BUILD MAX HEAP Alg: BUILD-MAX-HEAP(A). n = length[a] 2. for i n/2 downto 3. do MAX-HEAPIFY(A, i, n) O(lgn) O(n) Running time: O(nlgn) This is not an asymptotically tight upper bound! Why? 6

13 Running Time of BUILD MAX HEAP MAX-HEAPIFY takes O(h) the cost of MAX-HEAPIFY on a node i proportional to the height of the node i in the tree Height h 0 = 3 ( lgn ) h = 2 Level i = 0 i = No. of nodes h 2 = i = h 3 = 0 i = 3 ( lgn ) 2 3 h i = h i height of the heap rooted at level i n i = 2 i number of nodes at level i T( n) h i 0 n h i i h i 0 2 i h i O( n) see the next slide

14 Running Time of BUILD MAX HEAP h T ( n ) n h i Cost of HEAPIFY at level i (# of nodes at that level) i 0 h i i 2 h i Replace the values of n i and h i computed before i 0 h i 0 h i 2 h i 2 k h h k k 0 2 h Multiply by 2 h both at the nominator and denominator and write 2 i as (/2 -i ) 2 Change variables: k = h - i n n k k k 0 2 ( O(n) / 2 2 / 2) The sum above is smaller than the sum of all elements to and h = lgn x=/2 in the summation k kx 2 k 0 ( x) Running time of BUILD-MAX-HEAP T(n) = O(n) x

15 Heapsort Goal: Sort an array using heap representations Idea: Build a max-heap from the array Swap the root (the maximum element) with the last element in the array Discard this last node by decreasing the heap size Call MAX-HEAPIFY on the new root Repeat this process until only one node remains 9

16 Example: A=[, 4, 3,, 2] MAX-HEAPIFY(A,, 4) MAX-HEAPIFY(A,, 3) MAX-HEAPIFY(A,, 2) MAX-HEAPIFY(A,, ) 20

17 Alg: HEAPSORT(A). BUILD-MAX-HEAP(A) O(n) 2. for i length[a] downto 2 3. do exchange A[] A[i] n- times 4. MAX-HEAPIFY(A,, i - ) O(lgn) Running time: O(nlgn) Can be shown to be Θ(nlgn) 2

18 Priority Queues Each element is associated with a value (priority) The key with the highest (lowest) priority is extracted first 4 5 Support the following operations: INSERT(S, x) : inserts element x into set S EXTRACT-MAX(S) : removes and returns element of S with largest key MAXIMUM(S) : returns element of S with largest key INCREASE-KEY(S, x, k) : increases value of element x s key to k (Assume k x s current key value)

19 HEAP-MAXIMUM Goal: Return the largest element of the heap Alg: HEAP-MAXIMUM(A). return A[] Running time: O() Heap A: Heap-Maximum(A) returns 23

20 HEAP-EXTRACT-MAX Goal: Idea: Extract the largest element of the heap (i.e., return the max value and also remove that element from the heap Exchange the root element with the last Decrease the size of the heap by element Call MAX-HEAPIFY on the new root, on a heap of size n- Heap A: Root is the largest element 24

21 Example: HEAP-EXTRACT-MAX max = Heap size decreased with 4 Call MAX-HEAPIFY(A,, n-) 0 4 2

22 HEAP-EXTRACT-MAX Alg: HEAP-EXTRACT-MAX(A, n). if n < 2. then error heap underflow 3. max A[] 4. A[] A[n] 5. MAX-HEAPIFY(A,, n-) % remakes heap 6. return max Running time: O(lgn) 26

23 HEAP-INCREASE-KEY Goal: Increases the key of an element i in the heap Idea: Increment the key of A[i] to its new value If the max-heap property does not hold anymore: traverse a path toward the root to find the proper place for the newly increased key 6 Key [i] i 2 4

24 Example: HEAP-INCREASE-KEY i 2 4 i 2 5 Key [i ] i i

25 Alg: HEAP-INCREASE-KEY(A, i, key). if key < A[i] 2. then error new key is smaller than current key 3. A[i] key 4. while i > and A[PARENT(i)] < A[i] 5. do exchange A[i] A[PARENT(i)] 6. i PARENT(i) Running time: O(lgn) i 2 4 Key [i] 5

26 MAX-HEAP-INSERT Goal: 6 Inserts a new element into a max-heap 4 0 Idea: Expand the max-heap with a new element whose key is - Calls HEAP-INCREASE-KEY to set the 6 key of the new node to its correct value and maintain the max-heap property

27 Example: MAX-HEAP-INSERT Insert value 5: Start by inserting - 6 Increase the key to 5 Call HEAP-INCREASE-KEY on A[] = The restored heap containing the newly added element

28 Alg: MAX-HEAP-INSERT(A, key, n). heap-size[a] n + 2. A[n + ] - 3. HEAP-INCREASE-KEY(A, n +, key) Running time: O(lgn)

29 Summary We can perform the following operations on heaps: MAX-HEAPIFY O(lgn) BUILD-MAX-HEAP O(n) HEAP-SORT O(nlgn) MAX-HEAP-INSERT O(lgn) HEAP-EXTRACT-MAX O(lgn) HEAP-INCREASE-KEY O(lgn) HEAP-MAXIMUM O() Average: O(lgn) 33