Notes on Heaps

Building a better priority queue

• Using linear data structures to represent priority queues: insert is O(1), extract is O(n).
• We could use binary search trees to represent priority queues: insert, extract, both O(h). For balanced binary trees this might be okay, but for imbalanced trees, this is worse than before.
• Using heaps : insert and extract are both O(lg(n))

The heap-order property

       (9)
      /   \
    (7)   (3)
    / \     \
  (5) (6)   (1)
  /
(2)

Heaps

• each node has at most a fixed number of children
• Each non-leaf node has all its childern excpet for at most one which is the deepest, rightmost non-leaf node.

  (not a heap)                      (heap)

       (9)                            (9)     
      /   \    		             /   \    
    (7)   (3)  		          (7)     (3)  
    /       \  		          / \     /
  (5)       (1)		        (5) (2) (1)
  /            		      
(2)

Complete binary trees

      (8)
     /   \
  (4)     (6)
  / \     / \
(3) (1) (5) (7)

      (8)                   (8)       
     /   \      	   /   \      
  (4)     (6)  	         (4)   (6)  
  / \     /    	         / 
(3) (1) (5)    	       (3) 

Heap operations

• insert
• maximum
• extractMax

maximum

The heap-order property implies that the item with maximum key must be stored at the root. So maximum can simply return the item at root.

insert

1. Add a new node at next open position in the complete tree.
2. Copy the item/key into that node.
3. If new node's key is greater than its parent's, swap, and repeat considering the parent node until heap-order property is reestablished.

extractMax

1. Save item at root.
2. Move contents of last (bottommost, rightmost) node to root.
3. Swap that item/key with the child that has the greater key.
4. Repeat previous step until heap-order property is reestablished.
5. Return the item originally at root.

Implementing heaps

• heap[0] is the root of the heap.
• For node at position i in the array,
  • left child is at position (2*i)+1
  • right child is at position (2*i)+2
  • parent is at position (i-1)/2
• a member variable count can keep track of how many items are in the heap and indicate the position for next insertion.

template <class Item, class Key>
class PQueue {
public:
  ...
  Item maximum() const;
  void insert(const Item& it, const Key& priority);
  Item extractMax();
  ...
private:
  ...
  typedef IKPair IKP;
  static const size_t INITIAL_CAPACITY = 2;
  IKP *heap; // dynamic array
  size_t count; 
  size_t capacity; // size of current dynamic array

  // Helper functions:		     
  size_t parent(size_t index) const;
  size_t left(size_t index) const;
  size_t right(size_t index) const;
  bool hasLeft(size_t index) const;
  bool hasRight(size_t index) const;
  void heapifyDown(size_t index);
  void heapifyUp(size_t index);
};

Faster sorting