堆（heap）——C++实现

 　　优先队列从名字我们就可以猜到，其与队列之间存在一定的练习，优先队列与队列一样主要是入队和出队两个操作。但是优先队列与队列的不同之处在于，优先队列会将优先级高的先出队，这在很多情况下非常有用。例如，Windows的MFC是基于消息的响应的机制，内部管理着一个消息队列，计算机不断从消息队列中抓取消息进行响应，那么系统的消息和应用软件的消息优先级必然不同，我们需要优先响应系统的消息，那么优先队列就显示它强大的功能。

　　堆的实现我们可以通过一个表，或者一个二叉树都可以实现。如果通过一个表实现，入队很方便，但是出队，必须遍历一遍表找到优先级最高的那个，需要花费O(N)的时间，效率太低。对于二叉树来说入队和出队都是O(logN)的时间复杂度，但是二叉树的频繁删除会导致树向右边倾斜，当然我们可以通过平衡树来解决这个问题，但是对于优先队列来说最简单的方式是通过二叉堆实现。

　　二叉堆的实质是一个数组，只是我们用完全二叉树的形式将其表述出来，完全二叉树与不完全二叉树的区别如下图：

 

　　数组的第一位我们空出来是为了去满足二叉堆的性质：设某元素所处于数组中的位置为i，那么他的左儿子的位置使2*i，他的父元素的位置在i/2；

　　因为对于堆来说插入比删除要频繁，因此将优先级最高的放在第一个，因为删除比插入麻烦的多。

　　以下是例程，用vector实现：

/************************************************************************/
/* 堆的实现                                                                     */
/************************************************************************/
#include<vector>
namespace stl
{
    template<typename T>
    class Heap
    {
    public:
        /************************************************************************/
        /*构造函数*/
        Heap(int capacity = 100)
            :size(0)   //堆中包含数据个数
        {
            H.resize(capacity);
        }

        ~Heap()
        {
        }

        bool isEmpty()
        {
            return size == 0;
        }

        void makeEmpty()
        {
            size = 0;
            for (auto it = H.begin(); it != H.end(); it++)
            {
                H.erase(it);
            }
        }
        /************************************************************************/
        /*插入函数 */
        void insert(const T & x)
        {
            //如果vector中已经存满了，重新分为大小，数组首地址不存数据
            if (size == H.size() -1)
            {
                H.resize(2*size);
            }
            //size大小加一
            for (int current = ++size; current > 1 && H[current/2] > x; current /= 2)
            {
                 H[current] = H[current/2];
            }
            //找到空位将x插入
            H[current] = x;
        }

        /*删除函数*/
        T deleteMin()
        {
            if (isEmpty())
            {
                throw();
            }
            int current, child;
            T returnVal = H[1];
            T lastElement = H[size--];   //将最后一个值保存下来，删除一个元素所以自减运算
            for (current = 1; 2 * current > size; current = child)
            {
                child = 2 * current;
                //防止访问越界
                if (child != size && H[2 * current] > H[2 * current + 1])  
                {
                    ++child;
                }
                //比较子较小的儿子与最后一个值的大小，如果儿子较小用儿子上滤，否则跳出循环
                if (H[child] < lastElement)
                {
                    H[current] = H[child];
                }
                else
                {
                    break;
                }
            }
            H[current] = lastElement;
            return returnVal;
        }

    private:
        std::vector<T> H;
        int size;
    };
}