binary-heap（二叉堆）原理及C++代码实现

二叉堆可以看做一个近似的完全二叉树，所以一般用数组来组织。

二叉堆可以分为两种形式：最大堆和最小堆。最大堆顾名思义，它的每个结点的值不能超过其父结点的值，因此堆中最大元素存放在根结点中。最小堆的组织方式刚好与最大堆相反，它的最小元素存放在根结点中。

维护堆性质最重要的两个算法就是向上维护和向下维护。简而言之，例如最大堆中根结点的值小于其子结点的值，这个时候就要向下维护，把根结点逐级下降到适合的位置。显而易见地，向上维护就是子结点的值比其父结点大时（最大堆中），将结点逐级上升到合适的位置。这两个方法保证堆的性质不会被破坏。

堆经常用来实现优先队列，最大堆就对应最大优先队列，最小堆同上。因为通过关键字来查找堆中具体元素的位置比较麻烦，所以一般通过在堆中存储对象的句柄，在对应的对象中也存储对应堆元素的句柄来直接定位到元素的位置。

二叉堆是堆中最容易实现的一种，也算是用的比较广泛的一种。我下面的代码给出了最大堆和最小堆的一部分关键操作，另外一部分则挑选其中一种来实现。

代码如下：（仅供参考）

 class Node {
 public :
     int value;
 public :
     Node(int v = ) : value(v) {}
 };

 class Heap {
     vector<Node> heap;
     int heap_size;

     int Left(int i) {return (i << ) + ;}  //下标从0开始
     int Right(int i) {return Left(i) + ;}
     int Parent(int i) {return (i - ) >> ;}
     void MaxHeapify(int i);  //使结点i维持最大堆性质(向下维护)
     void MinHeapify(int i);  //使结点i维持最小堆性质(向下维护)
     void IncreaseKey(int i, int k);  //将结点i的value上升到k(向上维护)
 public :
     Heap() : heap_size() {}
     Heap(vector<Node> &t) : heap(t), heap_size(t.size()) {}
     void BuildMaxHeap();     //建立最大堆，时间复杂度O(n);
     void BuildMinHeap();     //建立最小堆，时间复杂度O(n);
     void MinHeapSort();     //从小到大排序，时间复杂度O(nlgn);
     void MaxHeapSort();     //从大到小排序，时间复杂度O(nlgn);
     //以下函数仅在最大堆下进行
     void Insert(int k); //插入一个元素（最大堆）
     void Delete(int i);    //删除一个元素（最大堆）
     Node Maximum();         //返回value最大的元素
     Node ExtractMax();     //去掉并返回value最大的元素
     //union two heap:union the vector of the two heaps, and call BuildMaxHeap()
     int Size() {return heap.size();} //返回vector的元素个数
     void PrintAll() {
         for (auto i : heap)
             cout << i.value << ends;
         cout << endl;
     }
 };

 void Heap::MaxHeapify(const int i) {
     int largest;
     if (Left(i) < heap_size && heap[Left(i)].value > heap[i].value)
         largest = Left(i);
     else
         largest = i;
     if (Right(i) < heap_size && heap[Right(i)].value > heap[largest].value)
         largest = Right(i);
     if (largest != i) {
         swap(heap[i], heap[largest]);
         MaxHeapify(largest);
     }
 }

 void Heap::MinHeapify(const int i) {
     int least;
     if (Left(i) < heap_size && heap[Left(i)].value < heap[i].value)
         least = Left(i);
     else
         least = i;
     if (Right(i) < heap_size && heap[Right(i)].value < heap[least].value)
         least = Right(i);
     if (least != i) {
         swap(heap[i], heap[least]);
         MinHeapify(least);
     }
 }

 void Heap::BuildMaxHeap() {
     heap_size = heap.size();
     for (int i = Parent(heap_size - ); i >= ; --i)
         MaxHeapify(i);
 }

 void Heap::BuildMinHeap() {
     heap_size = heap.size();
     for (int i = Parent(heap_size - ); i >= ; --i)
         MinHeapify(i);
 }

 void Heap::MinHeapSort() {
     BuildMaxHeap();
     for (int i = heap.size() - ; i > ; --i) {
         swap(heap[i], heap[]);
         --heap_size;
         MaxHeapify();
     }
 }

 void Heap::MaxHeapSort() {
     BuildMinHeap();
     for (int i = heap.size() - ; i > ; --i) {
         swap(heap[i], heap[]);
         --heap_size;
         MinHeapify();
     }
 }

 void Heap::Insert(int k) {
     heap.push_back(INT_MIN);
     IncreaseKey(heap.size() - , k);
 }

 void Heap::Delete(int i) {
     if (heap[heap.size() - ].value > heap[i].value) {
         IncreaseKey(i, heap[heap.size() - ].value);
         heap.pop_back();
     } else {
         heap[i] = heap[heap.size() - ];
         heap.pop_back();
         heap_size = heap.size();
         MaxHeapify(i);
     }
 }

 Node Heap::Maximum() {
     return heap[];
 }

 Node Heap::ExtractMax() {
     Node max = heap[];
     heap[] = heap[heap.size() - ];
     heap.pop_back();
     MaxHeapify();
     return max;
 }

 void Heap::IncreaseKey(int i, int k) {
     if (k <= heap[i].value)
         return ;
     while (i >  && heap[Parent(i)].value < k) {
         heap[i] = heap[Parent(i)];
         i = Parent(i);
     }
     heap[i].value = k;
 }