堆的实现以及优先级队列

堆的概念

堆是将一组数据按照完全二叉树的存储顺序，将数据存储在一个一维数组中的结构。
堆有两种结构，一种称为大顶堆，一种称为小顶堆，如下图。
小顶堆：任意结点的值均小于等于它的左右孩子，并且最小的值位于堆顶，即根节点处。
大顶堆：任意结点的值均大于等于它的左右孩子，并且最大的值位于堆顶，即根节点处。

既然是将一组数据按照树的结构存储在一维数组中，那么父子之间关系的建立就很重要了。
假设一个节点的下标为i。
1、当i = 0时，为根节点。
2、当i>=1时，父节点为（i - 1）/2

堆的实现

以下面这个例子来建堆，

int arr[10] = {12,23,54,2,65,45,92,47,204,31}arr.size() = 10;

先看一下一次调整：
1、int i = (size - 2)/2 = 4找到数组中的4号下标。
65大于其孩子，满足大堆性质，所以不用交换。

2、i= i-1；然后用2和其孩子比较，2和204交换。交换之后满足大堆

3、54和其孩子比较，54和92交换。交换之后满足大堆性质

4、23和其孩子比较，23和204交换

交换完之后，它的子树却不满足了，所以还需调整它的子树。

5、12和204交换。

因为每一次调整都可能会影响到你的子树不满足，所以当你修改了一个节点后，一定要再去判断它的子树还是否满足，即需要向下调整。

插入

在堆中插入一个元素，因为本身堆是建好的，所以满足性质，插入一个在树的最后，只需要顺着这条支路做一次调整就好了，不过这次不需要向下调整了，因为父节点肯定是大于子节点的。

如图，如果插入的节点大于它的父节点，发生交换是肯定不会影响其子树的，因为父节点本身就大于它的子节点，更何况交换后的节点是大于父节点的。所以，这里只需要一次简单的向上调整就可以完成。

删除
因为堆本身就是一种特殊的结构，所以一般对堆中的数据进行操作都是针对堆顶的元素，即针对最大值或最小值，比如哈夫曼树就用堆的结构来实现，因为每次要找出最小的两个数。
所以我们删除的时候，一般也是删除堆顶那个最小或最大的值，但是如果直接删掉堆顶，整个堆的结构被破坏了，必须重现建堆，这样无疑效率非常低，所以采用将堆中最后一个元素和堆顶元素进行替换，然后删除堆中最后一个元素。

这样进行替换删除后，以堆顶为根的树不满足堆的性质，只需要进行一次简单的向下调整即可。

下面是实现堆的代码，因为考虑到大小堆问题，所以使用了仿函数，这样只需多给定一个参数即可控制是大堆还是小堆。

下面给出完整代码：

#pragma once#include<iostream>#include<vector>#include<assert.h>using namespace std;template <class T>class Less{public:    bool operator()(const T& l, const T& r)    {        return l < r;    }};template <class T>class Greader{public:    bool operator()(const T& l, const T& r)    {        return l > r;    }};template <class T,class Compare = Greader<T>>class Heap{public:    Heap()    {}    Heap(const T a[], size_t n)    {        _heap.resize(n);        for (size_t i = 0; i < n; ++i)        {            _heap[i] = a[i];        }        for (int root = (_heap.size()-2) >> 1; root >= 0; --root)        {            AdJustDown(root);        }    }    void Push(const T& value)    {        _heap.push_back(value);        if(_heap.size() > 1)        AdJustUp();    }    void Pop()    {        assert(_heap.size() > 0);        swap(_heap[0], _heap[_heap.size() - 1]);        _heap.pop_back();        if (_heap.size() > 0)//防止堆中只有一个节点，删除后为0        AdJustDown(0);    }    const T& Top()//定义为const，防止堆顶被改破坏结构    {        return _heap[0];    }    size_t Size()    {        return _heap.size();    }    bool Empty()    {        return _heap.empty();    }private:    void AdJustDown(int root)    {        int parent = root;        int child = root * 2 + 1;        while (child < _heap.size())        {            if ((child + 1) < _heap.size() && Compare()( _heap[child + 1] , _heap[child]))                ++child;            if (Compare()(_heap[child],_heap[parent]))            {                swap(_heap[parent] , _heap[child]);                parent = child;                child = child * 2 + 1;            }            else            {                break;            }        }    }    void AdJustUp()    {        int child = _heap.size() - 1;        int parent = (child - 1) >> 1;        while (parent >= 0)//chile > 0        {             if (Compare()(_heap[child] , _heap[parent]))            {                swap(_heap[child], _heap[parent]);                child = parent;                parent = (child - 1) >> 1;            }            else            {                break;            }        }    }private:    vector<T> _heap;};

---

优先级队列

在C++的标准库中，提供了优先级队列这个容器，其实底层就是一个堆的结构，只不过将堆封装了一层而已。其实名字叫个优先级队列，但总觉得和队列是不沾边的。
priority_queue 是容器适配器，它提供常数时间的（默认）最大元素查找，对数代价的插入与释出。
用 priority_queue 工作类似管理某些随机访问容器中的堆，好处是不可能突然把堆非法化。
下面给出代码：

#pragma once#include"Heap.h"template<class T,class Compare=Greader<T>>class Priority_Queue{public:    Priority_Queue()    {}    ~Priority_Queue()    {}    const T& Top()const    {        return hp.Top();    }    bool Empty()    {        return hp.Empty();    }    size_t Size()    {        return hp.Size();    }    void Pop()    {        hp.Pop();//堆中已经对元素的个数进行了判断    }    void Push(const T& data)    {        hp.Push(data);    }    void Print_Queue()    {        while (!hp.Empty())        {            cout << hp.Top() << " ";            hp.Pop();          }        cout << endl;    }private:    Heap<T,Compare> hp;};