数据结构：优先队列--堆

堆是一棵被完全填满的二叉树。底层可以例外。也成为完全二叉树。

因为完全二叉树很有规律，所以可以用一个数组表示而不需要使用链。

对于任一个位置i上的元素，左儿子在2i上，右儿子在2i+1上。其父亲在i/2上。

堆的某个结点，必须必它的子孙结点都小，所以堆是完全二叉树，但是完全二叉树不一定是堆。

//
// Heap.h
// HelloWorld
// csdn blog：http://blog.csdn.net/u012175089
// Created by feiyin001 on 17/1/10.
// Copyright (c) 2017年 FableGame. All rights reserved.
//

#ifndef __HelloWorld__Heap__
#define __HelloWorld__Heap__
#include "Vector.h"

namespace Fable {
template<typename Comparable>
class BinaryHeap
{
public:
//默认构造函数
explicit BinaryHeap(int capacity = 100):array(capacity){}
//用已有的数组创建堆的构造函数
explicit BinaryHeap(const Vector<Comparable>& items)
:array(items.size() + 10), currentSize(items.size())
{
//插入数据
for (int i = 0; i < items.size(); i++)
{
array[i+1] = items[i];
}
//构建堆
buildHeap();
}

bool isEmpty()const
{
return currentSize == 0;
}
const Comparable& findMin()const
{
return array[1];
}
//插入数据
void insert(const Comparable& x)
{
//如果容量不够，就扩展一倍
if (currentSize == array.size() - 1)
{
array.resize(array.size() * 2);
}
//下表号是从1开始的，所以是自增之后
int hole = ++currentSize;
for (; hole > 1&& x < array[hole/2]; hole /= 2)//比父结点小，交换，交换到根结点，也就是1的时候，就要停止了
{
array[hole] = array[hole/2];//把父结点往下移动
}
array[hole] = x;//x放在最新的位置上面
}
//删除最小的一项
void deleteMin()
{
if (isEmpty()) {
throw "UnderflowException";//抛异常
}
array[1] = array[currentSize--];
percolateDown(1);//进行下虑
}
//删除最小的一项
void deleteMin(Comparable& minItem)
{
if (isEmpty()) {
throw "UnderflowException";//抛异常
}
minItem = array[1];
array[1] = array[currentSize--];
percolateDown(1);//进行下虑
}
void makeEmpty()
{
currentSize = 0;
}
private:
int currentSize;
Vector<Comparable> array;
//构建堆，主要应用在乱序的数据上面
void buildHeap()
{
//大于currentSize/2的结点已经在最底层，是不需要下滤的了。
for (int i = currentSize/2; i>0; i--)//必须从下往上进行下虑
{
percolateDown(i);
}
}
//下虑，将不适合的对象往下沉到适合的位置，O(logN)
void percolateDown( int hole )
{
int child;
Comparable tmp = array[hole];//当前位置的对象
for (; hole * 2 <= currentSize; hole = child)//当前位置如果没有子节点了，就终止循环，循环过后检测孩子的位置的数据
{
child = hole * 2;//第一个孩子
if (child != currentSize && array[child + 1] < array[child])
{
child++;//第二个孩子比第一个孩子小，选中小的一个
}
if (array[child] < tmp)//孩子比对象小
{
array[hole] = array[child];//把孩子往上移
}
else
{
break;//比最小的孩子还小，这个位置是合适的了。
}
}
array[hole] = tmp;//把对象放到孩子的位置。
}
};
}

#endif /* defined(__HelloWorld__Heap__) */

这是一般意义长的堆，因为用得最多。其实还有最大堆，根比子节点大。

STL实现了一个最大堆，而不是最小堆。

下面的堆概念平时比较少用到，以后要用到再研究了。

d堆：是二叉堆的简单推广，所有结点都有d个儿子。
查找儿子和父亲的乘法和除法都和因子d有关。

除非d是2的幂，否则将不能通过二进制移位来实现触发而导致运行时间急剧增加。

除了不能执行find操作外，两个堆合二为一是很困难的操作。

左式堆：以堆的形式构建，父节点比子节点小，不同的是，不是完全二叉树。

零路径长（null path length）npl(X)定义为从X结点到一个不具有两个儿子的节点的最短路径的长。

因此具有0或1个儿子的结点的npl为0.npl(NULL) == -1

斜堆（skew heap）是左式堆的自调节形式。

二项队列：一个二项队列不是一棵堆序的树，而是堆序的树的集合，称为森林。