priority_queue的简单实现

优先级队列相对于普通队列，提供了插队功能，每次最先出队的不是最先入队的元素，而是优先级最高的元素。

它的实现采用了标准库提供的heap算法。该系列算法一共提供了四个函数。使用方式如下：

首先建立一个容器，放入元素:

vector<int> vec;
insertNums(vec, 3, 7);
insertNums(vec, 5, 9);
insertNums(vec, 1, 4);

打印结果为:

all elements
3 4 5 6 7 5 6 7 8 9 1 2 3 4 

然后调用make_heap()， 将容器内[begin(), end())的元素建立成堆:

make_heap(vec.begin(), vec.end());

打印结果为:

after make heap
9 8 6 7 7 5 5 3 6 4 1 2 3 4 

然后我们调用pop_heap(),该算法必须保证[begin(),end())之间的元素已经是一个堆，

然后它将堆顶的元素放到最后，再将[begin(),end() - 1)内的元素重新排列成堆:

pop_heap(vec.begin(), vec.end());
vec.pop_back();
print(vec, "after pop heap");

打印结果为:

after pop heap
8 7 6 7 4 5 5 3 6 4 1 2 3 

接下来调用push_heap(),该算法必须保证[begin(),end() - 1)已经是一个堆，再将整个[begin(),end())调整为一个堆:

vec.push_back(17);
push_heap(vec.begin(), vec.end());
print(vec, "after push heap");

打印结果为:

after push heap
17 7 8 7 4 5 6 3 6 4 1 2 3 5 

最后我们调用sort_heap(),将[begin(),end())中的元素转化为有序序列，前提是[begin(),end())已经是一个堆:

sort_heap(vec.begin(), vec.end());
print(vec, "after sort heap");

打印结果为:

after sort heap
1 2 3 3 4 4 5 5 6 6 7 7 8 17 

完整的测试代码为:

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

template <typename T>
void insertNums(T &t, int first, int last)
{
    while(first <= last)
    {
        t.insert(t.end(), first);
        ++ first;
    }
}

template <typename T>
void print(const T &t, const std::string &s = "")
{
    cout << s << endl;
    for(typename T::const_iterator it = t.begin();
        it != t.end();
        ++ it)
        cout << *it << " ";
    cout << endl;
}

int main(int argc, char const *argv[])
{
    vector<int> vec;
    insertNums(vec, 3, 7);
    insertNums(vec, 5, 9);
    insertNums(vec, 1, 4);

    print(vec, "all elements");

    make_heap(vec.begin(), vec.end());
    print(vec, "after make heap");


    pop_heap(vec.begin(), vec.end());
    vec.pop_back();
    print(vec, "after pop heap");

    vec.push_back(17);
    push_heap(vec.begin(), vec.end());
    print(vec, "after push heap");

    sort_heap(vec.begin(), vec.end());
    print(vec, "after sort heap");
    return 0;
}

根据以上算法，我们来实现优先级队列priority_queue，代码如下:

#ifndef PRIORITY_QUEUE_H
#define PRIORITY_QUEUE_H
#include <vector>
#include <algorithm>
#include <functional>

template <typename T,
          typename Container = std::vector<T>,
          typename Compare = std::less<typename Container::value_type> >
class PriorityQueue
{
public:
    typedef typename Container::value_type     value_type;
    typedef typename Container::size_type     size_type;
    typedef Container                        container_type;
    typedef value_type&                     reference;
    typedef const value_type&                const_reference;

    PriorityQueue(const Compare &comp = Compare(),
                  const Container &cont = Container());



    template <typename InputIter>
    PriorityQueue(InputIter first, InputIter last,
                  const Compare &comp = Compare(),
                  const Container &cont = Container());

    void push(const value_type &val)
    {
        _cont.push_back(val);
        std::push_heap(_cont.begin(), _cont.end(), _comp);
    }

    void pop()
    {
        std::pop_heap(_cont.begin(), _cont.end(), _comp);
        _cont.pop_back();
    }

    bool empty() const { return _cont.empty(); }
    size_type size() const { return _cont.size(); }

    const_reference top() const { return _cont.front(); }

private:
    Compare _comp;
    Container _cont;

};

template <typename T, typename Container, typename Compare>
PriorityQueue<T, Container, Compare>::PriorityQueue(const Compare &comp,
                                                    const Container &cont)
        :_comp(comp), _cont(cont)
    {
        std::make_heap(_cont.begin(), _cont.end(), _comp);
    }


template <typename T, typename Container, typename Compare>
template <typename InputIter>
PriorityQueue<T, Container, Compare>::PriorityQueue(InputIter first, InputIter last,
                                                    const Compare &comp,
                                                    const Container &cont)
    :_comp(comp), _cont(cont)
{
    _cont.insert(_cont.end(), first, last);
    std::make_heap(_cont.begin(), _cont.end(), _comp);
}

#endif

测试代码如下:

#include "priority_queue.hpp"
#include <iostream>
using namespace std;

int main(int argc, const char *argv[])
{
    PriorityQueue<float> q;
    q.push(66.6);
    q.push(22.3);
    q.push(44.4);

    cout << q.top() << endl;
    q.pop();
    cout << q.top() << endl;
    q.pop();
    q.push(11.1);
    q.push(55.5);
    q.push(33.3);
    q.pop();

    while(!q.empty())
    {
        cout << q.top() << " ";
        q.pop();
    }
    cout << endl;



    return 0;
}

测试结果为:

66.6
44.4
33.3 22.3 11.1