Array representation of Binary Trees
 ====================================


           1
         2    3
       4   5 6  7
     8   9
 Array format:  Node, Left, Right Not achievable


 Array format:  Row Order
 { 1 2 3 4 5 6 7 8 9}

  0   1  2  3  4  5 6  7   8
 +--+--+--+--+--+--+--+--+--+-
 | 1| 2| 3| 4| 5| 6| 7| 8| 9|
 +--+--+--+--+--+--+--+--+--+-

 Left(0) is at 1
 Right(0) is at 2
 Left(1) 3
 Right(1) 4
 Left(2) 5
 Right(2) 6
 Left(3) 7
 Right(3) 8

 Index  | Left | Right
 -------+------+------
   0    |  1   |  2
   1    |  3   |  4
   2    |  5   |  6
   3    |  7   |  8

 LEFT(i) = 2i + 1
 RIGHT(i) = 2i + 2
 PARENT(i) = (i -1) / 2

 Drawbacks
   - Can't grow the tree
   - Can't represent sparse trees
     - represent empty nodes
        * sentinel value
        * parallel array of booleans
 Good for
   - Quick and dirty trees
   - Serializing trees (store in a file)
   - Data structure/tree format which ensures that the tree can be
     filled from left to right. (for example, heaps)

 Heaps
 =====
 A tree structure where every node obeys a heap property.

   Example Properties
     - MIN Heap property.  The root of every tree is the minimal
       value in that tree. All nodes below the root have a larger key
       value.

           1
         2   3
       4  5 6  7

     - MAX Heap Property   The root node is the largest node value in
       that tree.  All nodes below the root have a smaller key value

             7
          5    6
        3   4 2 1

 Uses
   - Priority Queue
       MIN HEAP Find the smallest item in constant time
       MAX HEAP Find the biggest item in constant time
       MIN MAX HEAP Find the biggest and the smallest in constant
       time

   - Sorting  (Heap Sort) O(n lg n)

   - Resource Allocation


 Basic Operations
   heapify(ar, i)
   - adjust ar[i] so that it conforms to the heap property


   buildHeap(ar, n)
   - reorders ar so that it is is in heap order

 Heap Representations
   Binary Heap:  Binary Tree
   Fibonocci Heap:  Very efficient but more difficult.