STL - priority_queue(优先队列)

参考:http://www.cnblogs.com/xzxl/p/7266404.html

一、基本定义:

优先队列容器与队列一样,只能从队尾插入元素,从队首删除元素。但是它有一个特性,就是队列中最大的元素总是位于队首,所以出队时,并非按照先进先出的原则进行,而是将当前队列中最大的元素出队。这点类似于给队列里的元素进行了由大到小的顺序排序。元素的比较规则默认按元素值由大到小排序,可以重载“<”操作符来重新定义比较规则。

优先级队列可以用向量(vector)或双向队列(deque)来实现(注意list container不能用来实现queue,因为list的迭代器不是任意存取iterator,而pop中用到堆排序时是要求randomaccess iterator 的!):
priority_queue<vector<int>, less<int> > pq1;     // 使用递增less<int>函数对象排序
priority_queue<deque<int>, greater<int> > pq2;   // 使用递减greater<int>函数对象排序
其成员函数有“判空(empty)” 、“尺寸(Size)” 、“栈顶元素(top)” 、“压栈(push)” 、“弹栈(pop)”等。

二、用途
最短路算法优化, 斜率DP优化等

三、代码实现&基本操作

///优先队列的基本使用
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;

///自定义优先级方法1,定义结构,使用运算符重载

struct cmp1
{
    bool operator ()(int &a, int &b)
    {
        return a > b; //最小值优先(是“>" 注意别与排序搞混)
    }
};

struct cmp2
{
    bool operator ()(int &a, int &b)
    {
        return a < b; //最大值优先
    }
};

///自定义优先级方法2,定义结构,使用运算符重载

struct numb_1
{
    int x;
    bool operator < (const numb_1 &a) const {
        return x > a.x; //最小值优先(与前面的联系记忆)
    }
};

struct numb_2
{
    int x;
    bool operator < (const numb_2 &a) const {
        return x < a.x; //最大值优先
    }
};

///测试用数据
int a[] = {2, 520, 30, 18, 4, 1314, 98, 0};
numb_1 num1[] = {2, 520, 30, 18, 4, 1314, 98, 0}; //用于自定义方法2
numb_2 num2[] = {2, 520, 30, 18, 4, 1314, 98, 0}; //用于自定义方法2

int main()
{
    ///采用默认优先级
    priority_queue<int> que; //(由大到小)构造队列(最单纯的优先队列)

    ///自定义优先级方法1
    priority_queue<int, vector<int>,cmp1> que1; //最小值优先
    priority_queue<int, vector<int>,cmp2> que2; //最大值优先

    ///使用系统的函数
    //(注意最后的括号,不是“<<”, 因为”<<“是右移运算符
    priority_queue<int, vector<int>, greater<int> > que3; //最小值优先
    priority_queue<int, vector<int>, less<int> > que4; //最大值优先

    ///自定义优先级方法2
    priority_queue<numb_1> que5; //最小值优先
    priority_queue<numb_2> que6; //最大值优先

    ///Let‘s begin

    ///入队操作
    for(int i = 0; a[i]; i++)
    {
        que.push(a[i]);
        que1.push(a[i]);
        que2.push(a[i]);
        que3.push(a[i]);
        que4.push(a[i]);
    }
    for(int i = 0; num1[i].x; i++)
        que5.push(num1[i]);
    for(int i = 0; num2[i].x; i++)
        que6.push(num2[i]);

    ///输出结果
    printf("采用默认优先级:\n");
    printf("(priority_queue<int>que;)\n");
    printf("Que 0:\n");
    while(!que.empty()) //判断是否为空
    {
        printf("%d ", que.top()); //队首元素
        que.pop(); //出队
    }
    puts("");
    puts("");

    printf("采用结构体自定义优先级方式一:\n");
    printf("(priority_queue<int,vector<int>,cmp>que;)\n");
    printf("Que 1:\n");
    while(!que1.empty()){
        printf("%d ",que1.top());
        que1.pop();
    }
    puts("");
    printf("Que 2:\n");
    while(!que2.empty()){
        printf("%d ",que2.top());
        que2.pop();
    }
    puts("");
    puts("");

    printf("采用头文件\"functional\"内定义优先级:\n");
    printf("(priority_queue<int,vector<int>,greater<int>/less<int> >que;)\n");
    printf("Que 3:\n");
    while(!que3.empty()){
        printf("%d ",que3.top());
        que3.pop();
    }
    puts("");
    printf("Que 4:\n");
    while(!que4.empty()){
        printf("%d ",que4.top());
        que4.pop();
    }
    puts("");
    puts("");

    printf("采用结构体自定义优先级方式二:\n");
    printf("(priority_queue<number>que)\n");
    printf("Que 5:\n");
    while(!que5.empty()){
        printf("%d ",que5.top());
        que5.pop();
    }
    puts("");
    printf("Que 6:\n");
    while(!que6.empty()){
        printf("%d ",que6.top());
        que6.pop();
    }
    puts("");
    return 0;

}

原文地址:https://www.cnblogs.com/ymzjj/p/9393438.html

时间: 2024-10-31 02:27:37

STL - priority_queue(优先队列)的相关文章

STL priority_queue 优先队列 小记

今天做题发现一个很有趣的地方,竟然还是头一次发现,唉,还是太菜了. 做图论用STL里的priority_queue去优化prim,由于特殊需求,我需要记录生成树中是用的哪些边. 于是,我定义的优先队列类型的数据结构如下: 1 struct node //优先队列存储结构,v存储节点号,e存储边号,dis[]为到该点的最短距离 2 { 3 int v,e; 4 node(){} 5 node(int _v,int _e):v(_v),e(_e){} 6 bool operator <(const

【STL】优先队列priority_queue详解+OpenJudge-4980拯救行动

一.关于优先队列 队列(queue)这种东西广大OIer应该都不陌生,或者说,队列都不会你还学个卵啊(╯‵□′)╯︵┻━┻咳咳,通俗讲,队列是一种只允许从前端(队头)删除元素.从后端(队尾)插入元素的数据结构.而优先队列(priority queue)是一种赋予每个队列中元素以一个优先级的队列.在执行删除操作时,优先队列会删除具有最高优先级的元素.如此奇妙的优先队列有什么用呢,举个例子,给定一个长为n的序列和m组询问,对于每组询问,我们要找出删去序列中最小的数,再向序列加入一个数.朴素的想法是对

STL - priority_queue(优先队列)

优先级队列priority_queue 最大值优先级队列.最小值优先级队列 优先级队列适配器 STL priority_queue 用来开发一些特殊的应用. priority_queue<int, deque<int>> pq; priority_queue<int, vector<int>> pq; pq.empty() pq.size() pq.top() pq.pop() pq.push(item) demo #include <iostream

详解C++ STL priority_queue 容器

详解C++ STL priority_queue 容器 本篇随笔简单介绍一下\(C++STL\)中\(priority_queue\)容器的使用方法和常见的使用技巧. priority_queue容器的概念 \(priority_queue\)在英文中是优先队列的意思. 队列是一种基本的数据结构.其实现的基本示意图如下所示: 而\(C++STL\)中的优先队列就是在这个队列的基础上,把其中的元素加以排序.其内部实现是一个二叉堆.所以优先队列其实就是把堆模板化,将所有入队的元素排成具有单调性的一队

第20章 priority_queue优先队列容器

/* 第20章 priority_queue优先队列容器 20.1 priority_queue技术原理 20.2 priority_queue应用基础 20.3 本章小结 */ // 第20章 priority_queue优先队列容器 // 20.1 priority_queue技术原理 // 20.2 priority_queue应用基础 -----------------------------------------------------------------------------

priority_queue优先队列/C++

priority_queue优先队列/C++ 概述 priority_queue是一个拥有权值观念的queue,只允许在底端加入元素,并从顶端取出元素. priority_queue带有权值观念,权值最高者,排在最前面. 缺省情况下priority_queue系利用一个max-heap完成,后者是一个以vector表现的complete binary tree. 定义 由于priority_queue完全以底部容器为根据,再加上heap处理规则,所以其实现非常简单.缺省情况下是以vector为底

C++ Primer 学习笔记_11_标准模板库_stack、queue队列容器与priority_queue优先队列容器

C++ Primer 学习笔记_11_标准模板库_stack.queue队列容器与priority_queue优先队列容器 1.stack堆栈 stack堆栈是一个后进先出(Last In First Out,LIFO)的线性表,插入和删除元素都只能在表的一端进行.插入元素的一端称为栈顶,而另一端称为栈底.插入元素叫入栈(Push),删除元素叫出栈(Pop).下图是堆栈示意图 堆栈只提供入栈,出栈,栈顶元素访问和判断是否为空等几种方法.采用push()方法将元素入栈:采用pop()方法出栈:采用

STL之priority_queue(优先队列)

priority_queue是一个容器适配器,在这个容器里第一个数据元素是最大的.它的使用场景是什么样:如果12306抢票,为什么黄牛能抢这么多票,感觉12306那边的请求队列是一个优先队列,黄牛的请求携带了一个隐含参数,所以他的请求最先执行.当然这是怀疑.不过也是优先级队列的使用场景.还可以进行排序,把数据压入优先队列中,然后出队列就是由大到小排列了 注意:stl的priority_queue容器需要一个boolean operator<(const T& ,const T&)函数

STL 之 优先队列(priority_queue)

1.什么是优先队列 能够完成下列两种操作的数据结构,我们便称之为优先队列. ①插入一个数值    ②取出最大(或者最小)的数值(获取数值,并且删除). 从严格意义上来说优先队列,并不是队列,因为它并不遵循队列的FIFO(先进先出的原则). 2.实现优先队列 我们可以使用一种叫做"堆(heap)"的数据结构来实现优先队列.堆有一个重要的性质就是儿子的值一定不小于父亲.除此之外,树的节点是从上到下.从左到右的顺序紧凑排列的.堆就是如下图的二叉树, 不知道是什么是二叉树的同学请移步:传送门