精华内容
下载资源
问答
  • STL 优先队列 定义 优先级

    千次阅读 2015-08-14 14:16:13
    默认的优先队列是个极大堆,如果要改变优先队列中元素的优先级,有下面这些方法

    默认的优先队列是个极大堆,如果要改变优先队列中元素的优先级,有下面这些方法

    struct cmp1  
    {    
        bool operator ()(int &a,int &b)  
        {    
            return a>b;//最小值优先     
        }    
    };    
    struct cmp2  
    {    
        bool operator ()(int &a,int &b)  
        {    
            return a<b;//最大值优先     
        }    
    };    
    struct node1  
    {    
        int u;    
        bool operator < (const node1 &a) const   
        {    
           return u>a.u;//最小值优先     
        }    
    };    
    struct node2  
    {    
        int u;    
        bool operator < (const node2 &a) const   
        {    
            return u<a.u;//最大值优先     
        }    
    };   
      
    priority_queue<int>q1;//采用默认优先级构造队列       
    priority_queue<int,vector<int>,cmp1>q2;//最小值优先     
    priority_queue<int,vector<int>,cmp2>q3;//最大值优先     
    priority_queue<int,vector<int>,greater<int> >q4;//注意“>>”会被认为错误,     
                                                    //这是右移运算符,所以这里用空格号隔开,最小值优先   
    priority_queue<int,vector<int>,less<int> >q5;//最大值优先      
    priority_queue<node1>q6;  //自定义优先级  
    priority_queue<node2>q7;


    展开全文
  • 默认优先级是从大到小. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 ...// 最大值优先 struct cmp1{ bool operator () (int &a, int &...

    默认优先级是从大到小.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    
    // 最大值优先
    struct cmp1{
        bool operator () (int &a, int &b){
            return a < b;
        }
    };
    
    // 最小值优先
    struct cmp2{
        bool operator () (int &a, int &b){
            return a > b;
        }
    };
    
    struct node1{
        int a, b;
        bool operator < (const node1 &temp) const{
            return a + b < temp.a + temp.b; // 以a + b 的值 最大值优先
        }
    };
    
    struct node2{
        int a, b;
        bool operator < (const node2 & temp) const{
            return a + b > temp.a + temp.b; // 以a + b 的值 最小值优先
        }
    };
    
    int main(){
        // 最大值优先
        priority_queue<int>q1;
        priority_queue<int, vector<int> , less<int> >q2; // 注意 less<int>>q2; 中间不加空格的话会报错, 因为是右移>> 运算符
        priority_queue<int, vector<int> , cmp1>q3;
        
        // 最小值优先
        priority_queue<int, vector<int>, greater<int> >q4; // 注意 greater<int>>q4; 中间不加空格的话会报错, 因为是右移>> 运算符
        priority_queue<int, vector<int>, cmp2> q5;
    
        // 结构体自定义优先级, 具体优先级顺序看上面
        priority_queue<node1>q6;
        priority_queue<node2>q7;
        return 0;
    }
    

    如何理解结构体中overload的小于号呢? (只能重载小于号)

    1. 可以理解为重载后小于号作用是比较出数组中优先级更小的数据,如果返回的是某个数据值更大的一方则值越大优先级越小,相反则值越小优先级越大。
    2. 优先队列是输出优先级最高的数据的队列。
    3. 可以简单的记为与sort中的cmp函数效果相反。
    恰似你一低头的温柔,较弱水莲花不胜寒风的娇羞, 我的心为你悸动不休。  --mingfuyan
    
    千万不要图快——如果没有足够的时间用来实践, 那么学得快, 忘得也快。
    展开全文
  • c++优先队列(priority_queue)用法详解

    万次阅读 多人点赞 2018-04-14 10:58:07
    优先队列具有队列的所有特性,包括基本操作,只是在这基础上添加了内部的一个排序,它本质是一个堆实现的 定义:priority_queue&lt;Type, Container, Functional&gt; Type 就是数据类型,Container 就是...

    既然是队列那么先要包含头文件#include <queue>, 他和queue不同的就在于我们可以自定义其中数据的优先级, 让优先级高的排在队列前面,优先出队

    优先队列具有队列的所有特性,包括基本操作,只是在这基础上添加了内部的一个排序,它本质是一个堆实现的

    和队列基本操作相同:

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

    定义:priority_queue<Type, Container, Functional>
    Type 就是数据类型,Container 就是容器类型(Container必须是用数组实现的容器,比如vector,deque等等,但不能用 list。STL里面默认用的是vector),Functional 就是比较的方式,当需要用自定义的数据类型时才需要传入这三个参数,使用基本数据类型时,只需要传入数据类型,默认是大顶堆
    一般是:

    //升序队列
    priority_queue <int,vector<int>,greater<int> > q;
    //降序队列
    priority_queue <int,vector<int>,less<int> >q;
    
    //greater和less是std实现的两个仿函数(就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator(),这个类就有了类似函数的行为,就是一个仿函数类了)
    

    1. 基本类型例子:
    #include<iostream>
    #include <queue>
    using namespace std;
    int main() 
    {
        //对于基础类型 默认是大顶堆
        priority_queue<int> a; 
        //等同于 priority_queue<int, vector<int>, less<int> > a;
        
      
        priority_queue<int, vector<int>, greater<int> > c;  //这样就是小顶堆
        priority_queue<string> b;
    
        for (int i = 0; i < 5; i++) 
        {
            a.push(i);
            c.push(i);
        }
        while (!a.empty()) 
        {
            cout << a.top() << ' ';
            a.pop();
        } 
        cout << endl;
    
        while (!c.empty()) 
        {
            cout << c.top() << ' ';
            c.pop();
        }
        cout << endl;
    
        b.push("abc");
        b.push("abcd");
        b.push("cbd");
        while (!b.empty()) 
        {
            cout << b.top() << ' ';
            b.pop();
        } 
        cout << endl;
        return 0;
    }
    

    输出

    4 3 2 1 0
    0 1 2 3 4
    cbd abcd abc
    

    2.pari的比较,先比较第一个元素,第一个相等比较第二个

    #include <iostream>
    #include <queue>
    #include <vector>
    using namespace std;
    int main() 
    {
        priority_queue<pair<int, int> > a;
        pair<int, int> b(1, 2);
        pair<int, int> c(1, 3);
        pair<int, int> d(2, 5);
        a.push(d);
        a.push(c);
        a.push(b);
        while (!a.empty()) 
        {
            cout << a.top().first << ' ' << a.top().second << '\n';
            a.pop();
        }
    }
    

    输出

    2 5
    1 3
    1 2
    

    3.对于自定义类型

    #include <iostream>
    #include <queue>
    using namespace std;
    
    //方法1
    struct tmp1 //运算符重载<
    {
        int x;
        tmp1(int a) {x = a;}
        bool operator<(const tmp1& a) const
        {
            return x < a.x; //大顶堆
        }
    };
    
    //方法2
    struct tmp2 //重写仿函数
    {
        bool operator() (tmp1 a, tmp1 b) 
        {
            return a.x < b.x; //大顶堆
        }
    };
    
    int main() 
    {
        tmp1 a(1);
        tmp1 b(2);
        tmp1 c(3);
        priority_queue<tmp1> d;
        d.push(b);
        d.push(c);
        d.push(a);
        while (!d.empty()) 
        {
            cout << d.top().x << '\n';
            d.pop();
        }
        cout << endl;
    
        priority_queue<tmp1, vector<tmp1>, tmp2> f;
        f.push(c);
        f.push(b);
        f.push(a);
        while (!f.empty()) 
        {
            cout << f.top().x << '\n';
            f.pop();
        }
    }
    

    输出

    3
    2
    1
    
    3
    2
    1
    
    展开全文
  • 优先队列的优先级定义

    千次阅读 2017-03-20 17:04:00
    这是stl里定义的比较结构 我们都知道用greater是小顶堆,less是大顶堆,默认是less。/// One of the @link comparison_functors comparison functors@endlink. template struct greater : public binary_function...

    记录一个菜逼的成长。。

    记下对优先队列对优先级改如何定义

    这是stl里定义的比较结构
    我们都知道用greater是小顶堆,less是大顶堆,默认是less。

    /// One of the @link comparison_functors comparison functors@endlink.
      template<typename _Tp>
        struct greater : public binary_function<_Tp, _Tp, bool>
        {
          bool operator()(const _Tp& __x, const _Tp& __y) const
          { return __x > __y; }
        };
    
     /// One of the @link comparison_functors comparison functors@endlink.
      template<typename _Tp>
        struct less : public binary_function<_Tp, _Tp, bool>
        {
          bool operator()(const _Tp& __x, const _Tp& __y) const
          { return __x < __y; }
        };

    如果我们自己定义一个结构可这样写
    假设定义了一个结构

    struct Node{
        int x,y,z;
    }

    我们模仿上面的比较结构自己定义一个比较结构,比如

    struct cmp{
        bool operator () (const Node& a,const Node& b) const{
            return a.y < b.y;//大顶堆,,改为>是小顶堆
        }
    }

    那么创建优先队列时这样写

    priority_queue<Node,vector<Node>,cmp>q;

    我们也可以通过重载运算符来定义优先级,比如

    struct Node{
        int x,y,z;
        friend bool operator > (const Node& a,const Node& b){
            return a.x > b.x; //greater,小顶堆
        } 
        friend bool operator < (const Node& a,const Node& b){
            return a.x < b.x;//less,大顶堆 
        } 
    }

    我们可以这样创建优先队列

    priority_queue<Node,vector<Node>,greater<Node> >q;
    priority_queue<Node,vector<Node>,less<Node> >q;
    展开全文
  • 优先队列

    2017-10-17 19:31:24
    优先队列在头文件#include 中; 其声明格式为:priority_queue ans;//声明一个名为ans的整形的优先队列 基本操作有: empty( ) //判断一个队列是否为空 pop( ) //删除队顶元素 push( ) //加入一个元素 size( )...
  • FIFO队列和优先队列

    千次阅读 2017-08-17 17:49:30
    FIFO队列和优先队列一.区别FIFO队列相当于一般的队列 优先队列为操作时有优先级的队列二....优先队列定义优先级1.默认优先级为优先级最高的先出队,默认的int类型的优先队列中先出队的为队列中较大的数。 2.小的优
  • 优先队列详解

    2017-11-23 22:11:20
    优先队列 定义 优先队列:顾名思义,首先它是一个队列,但是它强调了“优先”二字,所以,已经不能算是一般意义上的队列了,它的“优先”意指取队首元素时,有一定的选择性,即根据元素的属性选择某一项值最优的出...
  • 优先队列排序

    千次阅读 2017-02-02 10:54:23
    优先队列
  • 优先队列是一种用来维护由一组元素构成的集合的数据结构,可以用堆来实现。在优先队列中,元素被赋予优先级,当访问元素时,具有最高级优先级的元素先被访问。 最大优先队列可用于共享计算机系统的作业调度等,最小...
  • 优先队列入门

    千次阅读 2016-10-02 14:49:05
    C++ Priority_Queue(优先队列) 优先队列是一种具有优先级的队列,对常规的队列取值是基于先进先出的顺序,而在优先队列中,选择具有了优先性。
  • 什么是优先队列

    千次阅读 多人点赞 2019-05-20 07:32:00
    来源:公众号【编程珠玑】 作者:守望先生 前言 我们之前已经介绍过《如何自己实现一个队列》,它们是先入先出的,...优先队列中的每个元素都有优先级,而优先级高(或者低)的将会先出队,而优先级相同的则...
  • 优先队列的两种自定义排序方式

    千次阅读 2018-11-16 17:06:23
    首先简单的优先队列定义方法有三种 1.默认从大到小排序 priority_queue&lt;int&gt;q; 2.等价于上面(从大到小排序) priority_queue&lt;int,vector&lt;int&gt;,less&lt;int&gt;...
  • STL优先队列详解

    千次阅读 2015-05-03 10:11:15
    优先队列  优先队列是一种抽象数据类型(Abstract Date Type,ADT),行为和队列... STL的优先队列定义在头文件和 (队列一样),用"priority_queuepq"来声明; 最基本的用法  定义:priority_queuepq;
  • pop() 弹出队列的第一个元素(队顶元素),注意此函数并不返回任何值 front() 返回第一个元素(队顶元素) back() 返回最后被压入的元素(队尾元素) empty() 当队列为空时,返回true size() 返回队列的长度 ...
  • 利用双向队列构造链接式优先队列

    千次阅读 2015-10-24 12:21:19
    优先队列定义 优先队列中的元素被赋予优先级。插入元素时保持优先队列部分有序,删除元素时具有最高优先级的元素最先删除。优先队列分为面向最高优先级的优先队列和面向最低优先级的优先队列。 数据结构二叉堆 当...
  • rabbitmq优先队列

    2019-05-19 11:29:43
    rabbitmq优先队列 优先队列:顾名思义,拥有高优先级的队列具有高的优先权,优先级高...可以在声明队列的时候设置x-max-priority参数来定义一个优先队列: Map<String, Object> map = new HashMap<>(); ...
  • 数据结构-优先队列

    2017-09-11 15:36:08
    优先队列的类定义 优先队列是0个或多个元素的集合,每个元素都有一个优先权或值,对优先队列执行的操作有1) 查找;2) 插入一个新元素;3) 删除.在最小优先队列(min priority queue)中,查找操作用来搜索优先权最小的...
  • 优先队列(Priority queue)

    千次阅读 2020-12-23 13:06:23
    优先队列有点类似于队列,但有一个重要的区别:每个元素都以优先级级别添加到优先队列中,进行出队列操作时,具有最高优先级的元素将先出队列。也就是说,元素是按优先级顺序存储在队列中的,而不是按插入顺序存储的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 109,595
精华内容 43,838
关键字:

优先队列定义优先方式