堆的介绍
Heap是一种数据结构具有以下的特点：
1）完全二叉树
2）heap中存储的值是偏序
Min-heap: 父节点的值小于或等于子节点的值
Max-heap: 父节点的值大于或等于子节点的值
堆的存储
一般都用数组来表示堆，i结点的父结点下标就为(i–1)/2。它的左右子结点下标分别为2 * i + 1和2 * i + 2。如第0个结点左右子结点下标分别为1和2。
由于堆存储在下标从0开始计数的数组中，因此，在堆中给定下标为i的结点时：
（1）如果i=0，结点i是根结点，无父结点；否则结点i的父结点为结点(i-1)/2；
（2）如果2i+1>n-1，则结点i无左子女；否则结点i的左子女为结点2i+1；
（3）如果2i+2>n-1，则结点i无右子女；否则结点i的右子女为结点2i+2。
堆的操作：小根堆插入元素
插入一个元素：新元素被加入到heap的末尾，然后更新树以恢复堆的次序。
每次插入都是将新数据放在数组最后。可以发现从这个新数据的父结点到根结点必然为一个有序的数列，现在的任务是将这个新数据插入到这个有序数据中——这就类似于直接插入排序中将一个数据并入到有序区间中。需要从下网上，与父节点的关键码进行比较，对调。
堆的操作：删除小根堆堆的最小元素
按定义，堆中每次都删除第0个数据。为了便于重建堆，实际的操作是将最后一个数据的值赋给根结点，堆的元素个数-1，然后再从根结点开始进行一次从上向下的调整。调整时先在左右儿子结点中找最小的，如果父结点比这个最小的子结点还小说明不需要调整了，反之将父结点和它交换后再考虑后面的结点。相当于从根结点将一个数据的“下沉”过程。
堆的操作：创建堆
对于叶子节点，不用调整次序，根据满二叉树的性质，叶子节点比内部节点的个数多1.所以i=n/2 -1 ，不用从n开始。就是从最后一个有叶子结点的结点开始。
堆排序
如果从小到大排序，创建大堆建好之后堆中第0个数据是堆中最大的数据。取出这个数据，放在数组最后一个元素上，将当前元素数-1，再执行下堆的删除操作。这样堆中第0个数据又是堆中最大的数据，重复上述步骤直至堆中只有一个数据时，数组元素就已经有序。
小根堆的实现
#include <iostream>
using namespace std;
const int DefaultSize = 50;
template<typename T>
class MinHeap
{
public:
//构造函数：建立空堆
MinHeap(int sz=DefaultSize)
{
maxHeapSize = (DefaultSize < sz) ? sz : DefaultSize;
heap = new T[maxHeapSize];
currentSize = 0;
}
//构造函数通过一个数组建立堆
MinHeap(T arr[],int n)
{
maxHeapSize = (DefaultSize < n) ? n : DefaultSize;
heap = new T[maxHeapSize];
for(int i=0;i<n;i++)
{
heap[i] = arr[i];
}
currentSize = n;
int currentPos = (currentSize - 2) / 2; //找最初调整位置:最后分支结点
while (currentPos>=0) //自底向上逐步扩大形成堆
{
siftDowm(currentPos, currentSize - 1); //局部自上向下下滑调整
currentPos--; //再向前换一个分支结点
}
}
//将x插入到最小堆中
bool Insert(const T& x)
{
if(currentSize==maxHeapSize)
{
cout << "Heap Full!" << endl;
return false;
}
heap[currentSize] = x; //插入
siftUp(currentSize); //向上调整
currentSize++; //堆计数+1
return true;
}
bool RemoveMin(T& x)
{
if(!currentSize)
{
cout << "Heap Empty!" << endl;
return false;
}
x = heap[0]; //返回最小元素
heap[0] = heap[currentSize - 1]; //最后元素填补到根结点
currentSize--;
siftDowm(0, currentSize - 1); //自上向下调整为堆
return true;
}
void output()
{
for(int i=0;i<currentSize;i++)
{
cout << heap[i] << " ";
}
cout << endl;
}
protected:
//最小堆的下滑调整算法
void siftDowm(int start, int end) //从start到end下滑调整成为最小堆
{
int cur = start;
int min_child = 2 * cur + 1; //先记max_child是cur的左子女位置
T temp = heap[cur];
while (min_child <=end)
{
if (min_child<end&&heap[min_child]>heap[min_child + 1]) //找到左右孩子中最小的一个
min_child++;
if(temp<=heap[min_child])
break;
else
{
heap[cur] = heap[min_child];
cur = min_child;
min_child = 2 * min_child + 1;
}
}
heap[cur] = temp;
}
//最小堆的上滑调整算法
void siftUp(int start) //从start到0上滑调整成为最小堆
{
int cur = start;
int parent = (cur - 1) / 2;
T temp = heap[cur];
while (cur>0)
{
if(heap[parent]<=temp)
break;
else
{
heap[cur] = heap[parent];
cur = parent;
parent = (parent - 1) / 2;
}
}
heap[cur] = temp; //回放temp中暂存的元素
}
private: //存放最小堆中元素的数组
T* heap;
int currentSize; //最小堆中当前元素个数
int maxHeapSize; //最小堆最多允许元素个数
};
//------------------------主函数-------------------------
int main(int argc, char* argv[])
{
MinHeap<int> h;
h.Insert(8);
h.Insert(5);
h.Insert(7);
h.Insert(9);
h.Insert(6);
h.Insert(12);
h.Insert(15);
h.output();
int out;
cout << static_cast<int> (h.RemoveMin(out)) << endl;
h.output();
int arr[10] = { 15,19,13,12,18,14,10,17,20,11 };
MinHeap<int> h1(arr,10);
h1.output();
}