C++和python: priority_queue优先队列

文章目录

    • 使用
    • 理论
    • 简单实现
      • C++
      • python

使用

priority_queue包含在头文件queue中,与通常的queue不同的就在于可以自定义其中数据的优先级,让优先级高的排在队列前面,优先出队,插入的效率为logn。
优先队列具有队列的所有特性,包括基本操作,只是在这基础上添加了内部的一个排序,它本质是一个堆实现的

  • top 访问队头元素
  • empty 队列是否为空
  • size 返回队列内元素个数
  • push 插入元素到队尾 (并排序)
  • emplace 原地构造一个元素并插入队列
  • pop 弹出队头元素
  • swap 交换内容

优先队列的使用

priority_queue< type, container, function > //function后注意有空格,避免>>
  • type:数据类型;
  • container:实现优先队列的底层容器,默认vector,还有deque,不能使用list;
  • function:元素之间的比较方式,使用基本数据类型时传入数据类型,默认大顶堆;
int main(){
    priority_queue<int> pq1;//默认less<> 大顶堆降序
    priority_queue<int, vector<int>, greater<int> > pq2;//小顶堆 升序
    priority_queue<string, vector<string>, less<string>>pq3;
    for(int i=0;i<4;++i){
        pq1.push(i); pq2.push(i); pq3.push(to_string(i));
    }
    cout<<pq1.top()<<endl;
    cout<<pq2.top()<<endl;
    cout<<pq3.top()<<endl;
}

3
0
3

c++优先队列(priority_queue)用法详解

理论

priority_queue 优先级队列之所以总能保证优先级最高的元素位于队头,是因为其底层采用堆数据结构存储结构。

priority_queue 底层采用vectordeque来存储元素的容器,而堆是一种数据结构,其本身无法存储数据,只能依附于某个存储介质,辅助其组织数据存储的先后次序。其次,priority_queue 底层采用 vector 或者 deque 作为基础容器,这毋庸置疑。但由于 vector 或 deque 容器并没有提供实现 priority_queue 容器适配器 “First in,Largest out” 特性的功能,因此 STL 选择使用堆来重新组织 vector 或 deque 容器中存储的数据,从而实现该特性。

简单的理解堆,它在是完全二叉树的基础上,要求树中所有的父节点和子节点之间,都要满足既定的排序规则:

  • 如果排序规则为从大到小排序,则表示堆的完全二叉树中,每个父节点的值都要不小于子节点的值,这种堆通常称为大顶堆;
  • 如果排序规则为从小到大排序,则表示堆的完全二叉树中,每个父节点的值都要不大于子节点的值,这种堆通常称为小顶堆;

我们可以尝试用堆结合基础容器 vector 或 deque 实现 priority_queue。值得庆幸的是,STL 已经为我们封装好了可以使用堆存储结构的方法,它们都位于 头文件中。表 2 中列出了常用的几个和堆存储结构相关的方法。

待续。。。

简单实现

C++

对优先队列做了一个简单的实现,诸多不足欢迎指正~

template <typename T>
class Pqueue{
public:
    Pqueue(){
        data = make_shared<vector<T>>(1);
        sort = false;
    };
    void push(T &t){
        data->push_back(t);
        sort = false;
    }
    void push(T &&t){
        data->emplace_back(t);
        sort = false;
    }
    T& top(){
        if(!sort){
            buildHeap();
            sort = true;
        }
        return (*data)[1];
    }
    void pop(){
        int n = (int)data->size();
        if(!sort){
            buildHeap();
        }
        swap((*data)[1], (*data)[n-1]);
        data->pop_back();
        sort = false;
    }
    bool empty() const {
        return data->size()<=1;
    }
private:
    shared_ptr<vector<T>> data;
    bool sort;
    void buildHeap(){
        int n = data->size();
        for(int i=n/2;i>=1;--i){
            cmp(i, n);
        }
    }
    void cmp(int i,int n){
        int l = 2*i, r = 2*i+1, t=i;
        if(l<n && (*data)[t]<(*data)[l]) t = l;
        if(r<n && (*data)[t]<(*data)[r]) t = r;
        if(t!=i){
            swap((*data)[t], (*data)[i]);
            cmp(t, n);
        }
    }
};

python

class PriorityQueue:
    def __init__(self, func, queue=None):
        self.queue = queue if queue else [0]
        self.func = func
        self.sort = False

    def push(self, item):
        self.queue.append(item)
        self.sort = False

    def pop(self):
        if len(self.queue) <= 1:
            return
        if not self.sort:
            self.build_heap()
        self.queue[1] = self.queue[-1]
        self.queue.pop()
        self.sort = False

    def top(self):
        if len(self.queue) <= 1:
            return None
        if not self.sort:
            self.build_heap()
            self.sort = True
        return self.queue[1]

    def build_heap(self):
        n = len(self.queue)
        if n > 1:
            for i in range(n//2, 0, -1):
                self.cmp_heap(i, n)

    def cmp_heap(self, i, n):
        left, right = i << 1, (i << 1)+1
        t = i
        if left < n and self.func(self.queue[left], self.queue[t]):
            t = left
        if right < n and self.func(self.queue[right], self.queue[t]):
            t = right
        if t != i:
            self.queue[t], self.queue[i] = self.queue[i], self.queue[t]
            self.cmp_heap(t, n)

STL priority_queue底层实现(深度剖析)
自定义比较函数
C++ priority_queue 与 lambda的结合使用
ACM向:关于优先队列priority_queue自定义比较函数用法整理

你可能感兴趣的:(C++,priority_queue)