STL源码剖析 priority_queue

最新推荐文章于 2024-09-19 20:56:21 发布

原创最新推荐文章于 2024-09-19 20:56:21 发布 · 405 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #stl

C++ 同时被 3 个专栏收录

248 篇文章

订阅专栏

C++ vector

53 篇文章

订阅专栏

STL

31 篇文章

订阅专栏

本文详细介绍了C++中的优先级队列(priority_queue)，它是一个基于最大堆的数据结构，用于存储具有权重的元素。元素根据其权重进行排序，权值最高的元素优先出队。priority_queue不提供迭代器，但提供了如empty、size、top、push和pop等操作。示例代码展示了如何创建和使用priority_queue，以及其内部如何通过泛型算法调整堆的结构。

priority_queue是一个拥有权重概念的queue，允许底部加入新的元素，头部删除旧的元素，以及审视元素数值的操作
priority_queue带有权重的概念，即元素按照权重进行排列，而不是按照插入队列的顺序进行排序。要求权值高者在前
缺省情况下，priority_queue使用max_heap完成，而max_heap物理层面是基于vector逻辑层面表现像complate binary tree；max_tree用于实现priority_queue的按照权值高低自动递增排序的特性

priority_queue定义完整列表

priority_queue底层使用vector，在加上堆的处理规则
priority_queue不被归纳为容器而是容器适配器

#include <iostream>
#include <vector>

#ifdef __STL_USE_EXCEPTIONS
#define __STL_TRY   try
#define __STL_UNWIND(action)   catch(...) { action; throw; }
#else
#define __STL_TRY
#define __STL_UNWIND(action)
#endif


template <class T,class Sequence = std::vector<T>,
          class Compare = std::less<typename Sequence::value_type>>
class priority_queue{
public:
    typedef typename Sequence::valuetype value_type;
    typedef typename Sequence::size_type size_type;
    typedef typename Sequence::reference reference;
    typedef typename Sequence::const_reference const_reference;
protected:
    Sequence c; //底层容器
    Compare comp; //元素大小的比较标准
public:
    priority_queue() : c (){}
    explicit priority_queue(const Compare& x) : c() ,comp(x){}
    //以下使用的make_heap()、push_heap()、pop_heap()都是泛型算法
    //注意 任意一个构造函数都立刻在底层容器内产生一个implicit representation heap
    //指代比较器
    template<class InputIterator>
    priority_queue(InputIterator first, InputIterator last,const Compare& x):
    c(first,last),comp(x){
        std::make_heap(c.begin(),c.end(),comp);
    }
    //没有指代比较器
    template<class InputIterator>
    priority_queue(InputIterator first, InputIterator last):
            c(first,last){
        std::make_heap(c.begin(),c.end(),comp);
    }
    bool empty()const{
        return c.empty();
    }
    size_type size() const{
        return c.size();
    }
    const_reference top()const{
        return c.front();
    }
    void push(const value_type& x){
        __STL_TRY{
            //push_heap 是泛型算法，先利用底层的push_back()将新的元素推入末端，再重新排列heap
            c.push_back(x);
            //push_heap 是泛型算法
            std::push_heap(c.begin(),c.end(),comp);
        }
        __STL_UNWIND(c.clear());
    }
    void pop(){
        __STL_TRY{
            //pop_heap是泛型算法，从heap中取出一个元素，并不是整整将这个元素弹出，而是重排heap
            //需要使用底层vector的pop_back()取得被弹出的元素
            std::pop_heap(c.begin(),c.end(),comp);
            c.pop_back();
        }
        __STL_UNWIND(c.clear());
    }


};

priority_queue没有迭代器

priority_queue的所有元素进出是有规则限制的，只有queue的顶端元素(权值最高者)才可以被外界使用
priority_queue不提供遍历的功能，因此无迭代器

测试用例

#include <iostream>
#include <vector>

#ifdef __STL_USE_EXCEPTIONS
#define __STL_TRY   try
#define __STL_UNWIND(action)   catch(...) { action; throw; }
#else
#define __STL_TRY
#define __STL_UNWIND(action)
#endif


template <class T,class Sequence = std::vector<T>,
          class Compare = std::less<typename Sequence::value_type>>
class priority_queue{
public:
    typedef typename Sequence::value_type value_type;
    typedef typename Sequence::size_type size_type;
    typedef typename Sequence::reference reference;
    typedef typename Sequence::const_reference const_reference;
protected:
    Sequence c; //底层容器
    Compare comp; //元素大小的比较标准
public:
    priority_queue() : c (){}
    explicit priority_queue(const Compare& x) : c() ,comp(x){}
    //以下使用的make_heap()、push_heap()、pop_heap()都是泛型算法
    //注意 任意一个构造函数都立刻在底层容器内产生一个implicit representation heap
    //指代比较器
    template<class InputIterator>
    priority_queue(InputIterator first, InputIterator last,const Compare& x):
    c(first,last),comp(x){
        std::make_heap(c.begin(),c.end(),comp);
    }
    //没有指代比较器
    template<class InputIterator>
    priority_queue(InputIterator first, InputIterator last):
            c(first,last){
        std::make_heap(c.begin(),c.end(),comp);
    }
    bool empty()const{
        return c.empty();
    }
    size_type size() const{
        return c.size();
    }
    const_reference top()const{
        return c.front();
    }
    void push(const value_type& x){
        __STL_TRY{
            //push_heap 是泛型算法，先利用底层的push_back()将新的元素推入末端，再重新排列heap
            c.push_back(x);
            //push_heap 是泛型算法
            std::push_heap(c.begin(),c.end(),comp);
        }
        __STL_UNWIND(c.clear());
    }
    void pop(){
        __STL_TRY{
            //pop_heap是泛型算法，从heap中取出一个元素，并不是整整将这个元素弹出，而是重排heap
            //需要使用底层vector的pop_back()取得被弹出的元素
            std::pop_heap(c.begin(),c.end(),comp);
            c.pop_back();
        }
        __STL_UNWIND(c.clear());
    }
};

int main(){
    int ia[9] = {0,1,2,3,4,8,9,3,5};
    priority_queue<int>iqp(ia,ia+9);
    std::cout << iqp.size() << std::endl; //9

    for (int i = 0; i < iqp.size(); ++i) {
        std::cout << iqp.top() << ' '; //9 9 9 9 9 9 9 9 9
    }
    std::cout << std::endl;

    while(!iqp.empty()){
        std::cout << iqp.top() << ' '; //9 8 5 4 3 3 2 1 0
        iqp.pop();
    }
    std::cout << std::endl;
}