【C++】优先级队列的模拟实现

优先级队列是在堆的基础上进行的一个扩展，主要是运用大堆来实现优先级队列，让优先度高的出队列，最大优先队列可以选用大堆，最小优先队列可以选用小堆来实现。
下面以最大优先队列来讲解其原理。
最大优先队列一般包括将一个元素插入到集合S中、返回集合S中具有最大key的元素、返回并删除集合S中具有最大key的元素等。
堆的实现代码如下
下面给出实现代码：

#include <vector>#include <assert.h>using namespace std;template<class T>struct Less{    bool operator()(const T& left, const T& right)    {        return left < right;    }};template<class T>struct Greater{    bool operator()(const T& left, const T& right)    {        return left > right;    }};template<class T, class Compare = Less<T>>class Heap{public:    Heap()    {}    Heap(const T array[], size_t size)    {        _heap.reserve(size);        for (size_t i = 0; i < size; i++)        {            _heap.push_back(array[i]);        }        for (int j = (_heap.size() - 2) / 2; j >= 0; j--)        {            _AdjustDown(j);        }    }    void Insert(const T& data)    {        assert(data);        assert(!_heap.empty());        _heap.push_back(data);        _Adjustup(_heap.size() - 1);    }    void Remove()    {        assert(!_heap.empty());        swap(_heap[0], _heap[size() - 1]);        _heap.pop_back();        _AdjustDown(0);    }    void Push(const T& x)      {          //插入到尾部，再从最后一个元素开始向上调整              _a.push_back(x);              AdjustUp(_a.size()-1);          }          void Pop()    {        //将堆顶与最后一个元素交换，再从堆顶下滑调整          assert(!_a.empty());        swap(_a[0], _a[_a.size() - 1]);        _a.pop_back();        if (_a.size()>1)         //如果堆中的元素大于一个，再进行调整          {            AdjustDown(0, _a.size());        }    }    size_t Size()const    {        return _heap.size();    }    bool Empty()const    {        return _heap.empty();    }    const T& Top()const    {        assert(!_heap());        return _heap[0];    }    void _AdjustDown(size_t parent)    {        assert(parent);        assert(!_heap.empty());        size_t child = parent * 2 - 1;        while (parent < _heap.size())        {            Compare com;            if (child + 1<_heap.size()&& com(_heap[child + 1], _heap[child]))            {                ++child;            }            if (child<_heap.size() && com(_heap[child], _heap[parent]))            {                swap(_heap[child], _heap[parent]);                parent = child;                child = parent * 2 + 1;            }            else                break;        }    }    void _AdjustUp(size_t child)    {        assert(!_heap.empty());        while(child)        {            Compare com;            size_t parent = (child - 1) / 2;            if (com(_heap[child], _heap[parent]))            {                swap(_heap[child], _heap[parent]);                child = parent;            }            else                break;        }    }private:    vector<T> _heap;};template<class T, class Compare = Less<T>>class PriorityQueue{public:    PriorityQueue()    {}    PriorityQueue(T* a, size_t size)        :_h(a, size)    {    }    void Push(const T& data)    {        _hp.push(data);    }    void Pop()    {        _hp.pop();    }    const T& Top()const    {        _hp.Top();    }    size_t Size()const    {        return _heap.size();    }    bool Empty()const    {        return _hp.Empty();    }protected:    Heap<T, Compare> _hp;};