A Introduction to Computing II Lecture 10: Heaps Fall Session 2000

Motivation Data structures supporting extraction of max element are quite useful, for example: Priority queues - list of tasks to perform with priority (always take highest priority task) Event simulators, e.g. video games (always simulate the nearest event in the future)

Heap Extract-Max() Insert(object, key)

How could we do this? Sorted list: but recall that Insertion-Sort was suboptimal Binary tree: but binary trees can become unbalanced and costly A more clever way: a special case of binary trees…

Arrays as Binary Trees Take an array of n elements: A[1..n] For an index i  [1.. n] define: Parent(i) = i/2 Left-child(i) = 2i Right-child(i) = 2i + 1

Example (as array)

Example (as tree)

Facts These trees are always balanced Easy to find next leaf to add (element n+1 in the array) Not as flexible as trees built with pointers

The Heap Property For any node X with parent PARENT(X): PARENT(X).key > X.key Compare to the Binary Search Tree Property from last lecture: this is a much weaker condition

Example

Heap-Insert Heap-Insert(A[1..n], k) { A.length ++; A[n+1] = k; j = n+1; while (j  1 and A[j] > A[PARENT(j)] { swap(A, j, PARENT(j)); j = PARENT(j); }

Heap-Insert: Example swap

Heap-Insert: Example swap 7

Heap-Insert: Example Done (15 < 16)

Helper routine: Heapify Given a node X, where X’s children are heaps, guarantee the heap property for the ensemble of X and it’s children X Left heapRight heap

Heapify Heapify(A[1..n], i) { l := Left(i); r := Right(i); if (A[i] > A[l] and A[i] > A[r] ) return; if (A[l] > A[r]) swap(A[i], A[l]); Heapify(A, l); else swap(A[i], A[l]); Heapify(A, l); }

Heapify: example HEAP PROPERTY VIOLATED

Heapify: example Swap with max(14, 6, 10) 14 6

Heapify: example Swap with max(8, 6, 7)

Heapify: example Done: 6 = max(2, 6, 4)

Heap-Extract-Max Heap-Extract-Max(A[1..n]) { returnValue = A[1]; A[1] = A[n]; heap.length --; Heapify(A[1..(n-1)], 1); return returnValue; }

Heap-Extract-Max: example returnValue = 16

Heap-Extract-Max: example Replace with A[n]

Heap-Extract-Max: example Heapify from top

Order of Growth Heap-insert Heapify Heap-Extract-Max O( log n ) All three, proportional to height of tree:

Other useful operations Build-Heap: convert an unordered array into a heap O( n ) Heap-Sort: sort by removing elements from the heap until it is empty O( n log n )

Build-Heap Build-Heap(A[1..n]) { for i :=  n/2  downto 1 Heapify(A, i); }

Heap-Sort Heap-Sort(A[1..n]) { result = new array[1..n]; for i := n downto 1 result[i] = Heap-Extract-Max (A[1..i]); return result; }

Any questions?