Heaps

• Heap: similar to a binary tree, but:
  • less stringent on ordering properties
  • Nodes have knowledge of parents
• Rules:
  1. The element at a node is <= its children (heap ordering)
  2. The tree is a complete binary tree: Every level contains its full allotment of children, except for the deepest, which is arranged from left to right (heap structuring)
  

• Only the upper left tree is actually a heap. The second violates the heap ordering property and and the third violates the heap structure property
• Often: we use the "implicit representation" to store our heaps: storing our heap in an array, rather than a tree.
  • "Top most" element: located at index 1.
  • leftChild(n) = 2n
  • rightChild(n) = 2n + 1
  • parent(n) = n/2
• Use this array, and a variable called index to implement our heap
  • index is the last element which is part of our heap
  • index is also the number of elements in our heap
• The heap from above would then be represented with the array:

  5

  11

  17

  21

  19

  31

  37

  29

  41

  and index = 9

Heap Operations

Adding an element:

1. increase index
2. place the new data item at index
3. while the new element has a smaller value than its parent, swap the new element and its parent
• This last step is known as "heapify up"
• Used to make sure that our newly inserted element ends up in the correct position
• May also be implemented recursively, as below

  heapifyUp(n)
  Input: n, the index of the node we are trying to swap up
  Assumes the heap is stored in an array A

      if n != 1 && A[n] < A[parent(n)]
          swap(n, parent(n))
          heapifyUp(parent(n))
  

• Running time: O(log n), where n is the number of elements in the heap
• Recall: the height of the heap is log n

Removing an element:


• When removing an element, always remove the root
1. Grab the root
2. Swap the element at index into the roots position
3. decrement index
4. while the "out of place element" has a larger priority than any child, swap the out of place element with the smallest child
• this last step is known as "heapify down", and can be implemented recursively

  heapifyDown(A, n):
  Input: the heap array, A; the index of the node that is out of place, n
  Postcondition: the node will (eventually) end up in the correct spot

      smallest = n
      l = leftChild(n)
      r = rightChild(n)
      if l <= index && A[l] < A[smallest]
          smallest = l
      if r <= index && A[r] < A[smallest]
          smallest = r
      if smallest != n
          swap(smallest, n)
          heapifyDown(A, smallest)
  

• Running time: O(log n)
• Reason: The maximum number of times we can call heapifyDown is the height of the heap, which is O(log n) because it is a complete tree

Heap uses

Priority Queues:

• Stores a priority along with a data
• dequeueing an item: remove element with highest priority (build a max heap rather than a min heap)

Heap sort:


• Can use a heap to sort an array

  heapSort(A)
  Input: An unsorted array, A
  Postcondition: A is sorted in descending order

      buildHeap(A)
      for i = index down to 1
          swap(i, 1)
          decrement index
          heapifyDown(1)
  

  buildHeap(A):
  Input: An array, A
  Postcondition: A is valid heap (heap order property is upheld)

      for i = index/2 down to 1
          heapifyDown(i)
  

• buildHeap is O(n) (this is a fact which I will not justify)
• We start at index/2 because this is the index of the first non-leaf node
• In sorting, we have n heapifyUps.
• Total running time of heapSort: O(n + nlog n) = O(nlog n)
• heapSort is also in place, and stable
Bulk loading
• Consider a heap which has n elements in it, and we wish to add an additional n elements to the heap (with no removes in between).
• Using standard insert, these n operations take a total time of O(nlog n) to perform necessary heapifyUp calls.
• Instead, we could add all of our elements at once, then call buildHeap to restore heap ordering property.
• This takes time O(n)
Simulations
• A series of events, all of which happen at specific times
• An event occurrence may cause other events to happen
• Have to process all of the events in order
• Can use a Priority Queue, which uses a MinHeap
• Time of event is the priority