源码系列：堆排序、优先队列

priority_queue.h

#ifndef PRIORITY_QUEUE_H_INCLUDED
#define PRIORITY_QUEUE_H_INCLUDED

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include <queue>

using namespace std;

namespace algo
{
    /// @brief 优先队列
    ///
    /// @param ItemType         队列中元素类型
    /// @param Comparator       用于比较队列中元素优先级的比饺子
    /// @param ContainerType    优先队列内部使用的容器类型
    template<
        typename ItemType,
        typename Comparator = less<ItemType>,
        typename ContainerType = vector<ItemType> >
    class PriorityQueue
    {
    public:
        typedef PriorityQueue<ItemType,Comparator,ContainerType> _MyType;
        typedef ItemType & Reference;
        typedef ItemType const & ConstReference;

        /// 创建空的优先队列
        PriorityQueue(){}

        /// 由一个区间初始化一个优先队列
        template<typename IterType>
        PriorityQueue(IterType begin,IterType end) : _queue(begin,end)
        {
            make_heap(_queue.begin(),_queue.end(),_comparator);
        }

        /// 向队列中添加一个元素
        void Push(ItemType const &item)
        {
            _queue.push_back(item);
            push_heap(_queue.begin(),_queue.end(),_comparator);
        }

        /// @brief 访问const的顶端元素
        /// @return 优先级最高的队首元素的const引用
        ConstReference Top() const
        {
            return *_queue.begin();
        }

        Reference Top()
        {
            return *_queue.begin();
        }

        /// 队首的元素出队
        void Pop()
        {
            pop_heap(_queue.begin(),_queue.end(),_comparator);
            _queue.pop_back();
        }

        /// 查询队列是否为空
        bool IsEmpty()
        {
            return _queue.empty();
        }

        /// 重新排序队列元素
        void RefreshQueue()
        {
            make_heap(_queue.begin(),_queue.end(),_comparator);
        }

        /// 输出队列中所有元素
        void Display()
        {
            copy(_queue.begin(),_queue.end(),ostream_iterator<ItemType>(cout,"  "));
            cout << endl;
        }

    private:
        ContainerType   _queue;         /// 容器
        Comparator      _comparator;    ///比饺子
    };
}

#endif // PRIORITY_QUEUE_H_INCLUDED

heap_sort.cpp

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>

using namespace std;

namespace algo
{
    /// 调整堆
    void MakeHeap(vector<int> &to_make, size_t length, size_t i)
    {
        size_t left = 2 * i + 1;
        size_t right = 2 * i + 2;
        size_t the_max = i;

        if(left < length && to_make[left] > to_make[i])
        {
            the_max = left;
        }
        if(right < length && to_make[right] > to_make[the_max])
        {
            the_max = right;
        }

        if(the_max != i)
        {
            std::swap(to_make[i],to_make[the_max]);
            MakeHeap(to_make,length,the_max);
        }
    }

    /// 基于数组建堆
    void BuildHeap(vector<int> &to_built)
    {
        for(int i=to_built.size()/2-1;i>=0;i--)
        {
            MakeHeap(to_built,to_built.size(),i);
        }
    }

    /// 堆排序
    void HeapSort(vector<int> &to_sort)
    {
        BuildHeap(to_sort);
        for(int i=to_sort.size()-1;i>0;i--)
        {
            std::swap(to_sort[0],to_sort[i]);
            MakeHeap(to_sort,i,0);
        }
    }
}

测试程序：

#include <iostream>
#include "heap_sort.cpp"
#include "priority_queue.h"

using namespace std;

int testHeapSort()
{
    int to_init[] = {8, 5, 78, 45, 64, 987, 45, 34, 23, 4, 23};
    vector<int> to_sort(to_init,to_init+sizeof(to_init)/sizeof(int));
    cout << "原始数组，准备进行堆排序：";
    copy(to_sort.begin(),to_sort.end(),ostream_iterator<int>(cout,"  "));
    algo::HeapSort(to_sort);
    cout << endl << "堆排序结束：";
    copy(to_sort.begin(),to_sort.end(),ostream_iterator<int>(cout,"  "));
    cout << endl << endl;

    cout << "初始化一个优先队列：";
    algo::PriorityQueue<int, greater<int> > queue;
    for(int i=0;i<10;i++)
    {
        queue.Push(rand() % 1000);
    }
    queue.Display();

    cout << "开始不断的取最高优先级的任务出列：" << endl;
    while(!queue.IsEmpty())
    {
        cout << queue.Top() << ":\t";
        queue.Pop();
        queue.Display();
    }

    cout << "开始添加任务入列：" << endl;
    for(size_t i=0;i<to_sort.size();i++)
    {
        queue.Push(to_sort[i]);
        queue.Display();
    }

    queue.Display();
    return 0;
}

int main()
{
    testHeapSort();
    return 0;
}

测试结果：