代码按照适配器模式实现，若理解了堆的内部怎么实现的，那优先级的队列实现则是非常简单的了，堆的设计大家不明白的话，可以查看我的博客http://10740184.blog.51cto.com/10730184/1767076。

创新互联建站专注于企业全网整合营销推广、网站重做改版、庆阳网站定制设计、自适应品牌网站建设、H5网站设计、商城系统网站开发、集团公司官网建设、外贸营销网站建设、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为庆阳等各大城市提供网站开发制作服务。

建立PriorityQueue.hpp：

#define _CRT_SECURE_NO_WARNINGS 1
#include
using namespace std;
#include
#include


template
struct Less
{
    bool operator() (const T& l, const T& r)
    {
        return l < r;
    }
};

template
struct Greater
{
    bool operator() (const T& l, const T& r)
    {
        return l>r;
    }
};


template class Compare=Less>
class Heap
{
public:
    Heap()
        :_a(NULL)
    {}


    Heap(const T* a,size_t size)
    {
        for (int i = 0; i < size; i++)
        {
            _a.push_back(a[i]);
        }
        for (int i = (size - 2) / 2; i >= 0; i--)
        {
            _adjustDown(i);
        }
    }


    void _adjustDown(size_t parent)
    {
        Compare com;
        size_t child = 2 * parent + 1;
        size_t size = _a.size();
        while (child com;
        while (child>0)
        {
            if (com(_a[child],_a[parent]))
            {
                swap(_a[parent], _a[child]);
                child = parent;
                parent = (child - 1) / 2;
            }
            else
            {
                break;
            }
        }
    }


    size_t Size()
    {
        size_t size = _a.size();
        return size;
    }


    bool Empty()
    {
        assert(Size() >= 0);
        return Size() == 0;
    }


    void Pop()
    {
        assert(_a.Size() > 0);
        swap(_a[0], _a[Size - 1]);
        _a.pop_back();
        _adjustDown(0);        
    }


    T& GetTop()
    {
        return _a[0];
    }


    void Print()
    {
        cout << "大堆序列：" << endl;
        for (int i = 0; i < _a.size(); i++)
        {
            cout << _a[i] << "  ";
        }
        cout << endl;
    }
public:
    vector _a;
};


template class Compare = Less>
class PriorityQueue
{
public:
    void Push(const T& x)
    {
        _hp.Push(x);
    }


    void Pop()
    {
        _hp.Pop();
    }


    size_t Size()
    {
        return _hp.Size();
    }


    bool Empty()
    {
        _hp.Empty();
    }


    T& Top()
    {
        return _hp.GetTop();
    }


    void Print()
    {
        _hp.Print();
    }
private:
    Heap _hp;
};

建立PriorityQueue.cpp文件：

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include "PriorityQueue.hpp"

void Test()
{
    int a[] = { 10, 11, 13, 12, 16, 18, 15, 17, 14, 19 };
    PriorityQueue pq;
    pq.Push(10);
    pq.Push(11);
    pq.Push(13);
    pq.Push(12);
    pq.Push(16);
    pq.Push(18);
    pq.Push(15);
    pq.Push(17);
    pq.Push(14);
    pq.Push(19);

    pq.Print();
}


int main()
{
    Test();
    system("pause");
    return 0;
}

另外有需要云服务器可以了解下创新互联scvps.cn，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。

当前题目：【数据结构】优先级队列的实现（适配器模式）-创新互联
新闻来源：http://scyanting.com/article/dospco.html