堆的实现以及优先级队列

堆的概念

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

既然是将一组数据按照树的结构存储在一维数组中，那么父子之间关系的建立就很重要了。
假设一个节点的下标为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;
};