Implementing Priority Queues: Heaps

• A heap is strange in that every operation will require some time based on the number of elements in the heap.
• A heap is a binary tree with the following property
  • For every element v, at a node i, the element w at i's parent satisifies key(w) ≤ key(v)
• We could build a heap in a binary tree

  • struct BTNodeT {
         datatype data;
         keytype key;
         BTNodeT * leftChild;
         BTNodeT * rightChild;
    } 

• But a simpler method is in an array
  • The root of the tree is at A[1]
  • The left child of the root is A[2]
  • The right child of the root is A[3]
  • In general For node i

  • Parent(i) = i/2  
    LeftChild(i)  = 2i
    RightChild(i) = 2i+1 

  • Draw the heap in the array {1, 2, 3, 10, 3, 7, 11, 15, 17, 20, 9, 15, 8, 16}

    Index	1	2	3	4	5	6	7	8	9	10	11	12	13	14
    Value	1	2	3	10	3	7	11	15	17	20	9	15	8	16

  • In this case the heap has 14 elements.
• To add an element
  • Add it to the last place in the array.
    • This means it might break the heap property
    • But only in the sub-tree where it has been inserted.
  • So HeapifyUp will bubule this to the right place.

  • HeapifyUp(H,i)
    
     While i >  1
         let j = parent(i)
         If H[i].key() < H[j].key()
             swap(H[i],H[j])
             i = j
         Else 
             i = 1
         EndIF
     EndWhle 
     

• To remove an element
  • Remove the element at the first position.
  • Replace it with the last element.
  • But this will break the heap as well so HeapifyDown

  • HeapifyDown(H,i)
    
     While 2*i < size
        left = LeftChild(i), right = RightCild(i);
        checkPos = left
        If right is valid and H[right].key < H[left].key
           checkPos = right
        EndIf
        If H[checkPos].key < H[i] 
            swap items at checkpos and i
            i = checkpos
        Else
            i = size
        EndIF
     EndWhile
    
             

• To prove things we need some definitions.
  • A binary tree is a graph where each node except the root has a single parent.
  • Each node can have at most two children.
  • The root of the binary tree is defined to have height 0
  • The height of any nodes is the number of edges between that node and the root.
  • Theorem: A binary tree has at most $2^h$ nodes at level $h$

    By Induction:
       Prove true for a base case:
          At level 0 a binary tree has at most 1 or 20 nodes. (the root)
       Assume true for an arbitrary k > 0 (the base case.)
          At level k, a binary tree has at most 2k nodes.
       Prove true for  for h = k+1 
          At level k there are at most 2k nodes (previous assumption)
          Each of these nodes can have at least 2 children (definition of binary tree)
          So there are at most 2*2k nodes at the next level.
          2*2k = 2k+1
             

  • Theorem: There are at most 2^h+1-1 nodes in a binary tree of height h.

    Observe from the previous proof that each level has at most 2h
    So a tree of height h has levels from 0 to h
             

    $$\sum_{i=0}^{h}2^i = 2^{h+1}-1 $$

    Think of this a binary number of all 1
    111 = 4 + 2 + 1 = 7 = 8-1 = 23-1
    1111 = 8 + 4 + 2 + 1 = 15 = 16-1 = 24-1