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

    2018-05-08 15:25:51
    有时候会忘,所以写个这个记录一下...struct cmp1{ bool operator ()(int &a,int &...//最小值优先 } }; struct cmp2{ bool operator ()(int &a,int &b){ ...


               有时候会忘,所以写个这个记录一下...

    struct cmp1{  
        bool operator ()(int &a,int &b){  
            return a>b;//最小值优先  
        }  
    };  
    
    struct cmp2{  
        bool operator ()(int &a,int &b){  
            return a<b;//最大值优先  
        }  
    };  
    
    //定义结构,使用运算符重载,自定义优先级2  
    struct number1{  
        int x;  
        bool operator < (const number1 &a) const {  
            return x>a.x;//最小值优先  
        }  
    };  
    
    struct number2{  
        int x;  
        bool operator < (const number2 &a) const {  
            return x<a.x;//最大值优先  
        }  
    };  
      
        priority_queue<int>que;//采用默认优先级构造队列  
      
        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;最大值优先  

    展开全文
  • 默认的优先队列是个极大堆,如果要改变优先队列中元素的优先级,有下面这些方法 struct cmp1 { bool operator ()(int &a,int &b) { return a>b;//最小值优先 } }; struct cmp2 { ...

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

    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;

     

    转载于:https://www.cnblogs.com/stranger-/p/7160577.html

    展开全文
  • stl优先队列定义>可以吗In this article, we are going to see how to write your comparator function for priority queue in C++ STL using the lambda function. This is going to help you certainly to use ...

    stl优先队列定义>可以吗

    In this article, we are going to see how to write your comparator function for priority queue in C++ STL using the lambda function. This is going to help you certainly to use priority queue more widely when you may have skipped thinking about how you can create a priority queue of your data type, or using your comparator.

    在本文中,我们将看到如何使用lambda函数 在C ++ STL中为优先级队列编写比较器 函数 。 当您可能不考虑如何创建数据类型的优先级队列或使用比较器时,这无疑将帮助您更广泛地使用优先级队列。

    Syntax for default priority queue in C++ STL is:

    C ++ STL中默认优先级队列的语法为:

    priority_queue<int> pq;
    
    

    By default the above priority queue works as the max heap, i.e., the maximum value from will come on the top and so on. So, if we pop and print we will have a sorted list in descending order.

    默认情况下,上述优先级队列用作最大堆,即from的最大值将排在顶部,依此类推。 因此,如果我们弹出并打印,我们将得到一个降序排列的列表。

    使用priority_queue STL创建最小堆 (Create min heap using priority_queue STL)

    We can use greater<int> class to define a min heap

    我们可以使用Greater <int>类来定义最小堆

    The syntax would be:

    语法为:

    priority_queue<int,vector<int>,greater<int>> pq;
    
    

    Where, vector<int> works as container and greater<int> as  comparator class,

    其中, vector <int>用作容器,Greater <int>用作比较器类,

    为优先级队列定义自己的比较器 (Define your own comparator for priority queue)

    You may have often come to a situation when you need to use a priority queue, but your datatype is something else that can't be compared by default (using '<' operator what is used by default). In such cases, we need to declare our comparator function.

    您可能经常遇到需要使用优先级队列的情况,但是您的数据类型是默认情况下无法比较的其他内容(默认情况下使用'<'运算符)。 在这种情况下,我们需要声明比较器函数。

    We can use the lambda function for that.

    我们可以为此使用lambda函数

    For example,

    例如,

    Say we need to compare the below object,

    假设我们需要比较以下对象,

    student{
        int roll
        int marks
    };
    
    

    And the comparison rule is if any two students have the same marks, then they would be sorted based on roll(whose roll comes first will have priority), otherwise, the student having more marks has more priority.

    比较规则是,如果任何两个学生的分数相同,则将基于掷骰进行排序(以掷骰优先),否则,得分更高的学生具有更高的优先级。

    How would we define the comparator for the above?

    我们如何定义以上比较器?

    Below is the use of lambda function which will be our comparator

    下面是lambda函数的使用,它将作为我们的比较器

    The syntax is:

    语法为:

    auto it=[](student a, student b){
        //comparison logic
        if(a.marks>b.marks)
            return false;
        else if(a.marks<b.marks)
            return true
        else //when marks are same
        if a.roll<b.roll
            return false
        else
            return true
    }; 
    
    

    The above is the lambda comparator function which takes as argument two data member and use the logic two compare, false means the current position is okay, that is no swap required, true means swap required.

    上面是lambda比较器函数 ,该函数将两个数据成员作为参数,并使用逻辑两个比较, false表示当前位置可以,即不需要交换, true表示需要交换。

    Now, the priority queue will be declared as:

    现在,优先级队列将声明为:

    priority_queue<student, vector<student>, decltype(it)> pq(it);
    
    

    Where it is our comparator function. One thing to notice that the comparator function is passed as constructor too.

    它是我们的比较器功能。 需要注意的一件事是,比较器函数也作为构造函数传递。

    So whenever you add an item to the priority queue,

    因此,无论何时将项目添加到优先级队列中,

    It does necessary swaps according to our user-defined logic and places the items in an order.

    它会根据用户定义的逻辑进行必要的交换,并按顺序放置项目。

    Example:

    例:

    Say we have 5 students with below data,

    假设我们有5位学生的数据如下,

    Roll	Marks
    1	65
    2	78
    3	87
    4	65
    5	78
    
    

    So inserting the first student data in the priority queue.

    因此,将第一个学生数据插入优先级队列。

    Since no other member.

    由于没有其他成员。

    Priority queue will be now,

    优先队列现在是

    1	65
    
    

    So inserting the second student data in the priority queue.

    因此,将第二个学生数据插入优先级队列。

    Now as per our comparator there will be swap.

    现在根据我们的比较器将进行交换。

    And thus, the priority queue will be now,

    因此,优先级队列现在是

    2	78
    1	65
    
    

    So, inserting the third student data in the priority queue.

    因此,在优先级队列中插入第三个学生数据。

    Now, as per our comparator, there will be a swap.

    现在,根据我们的比较器,将进行交换。

    And thus, the priority queue will be now,

    因此,优先级队列现在是

    3	87
    2	78
    1	65
    
    

    So, inserting the fourth student data in the priority queue.

    因此,在优先级队列中插入第四个学生数据。

    And thus as per our comparator, the priority queue will be now,

    因此,根据我们的比较器,优先级队列现在为

    3	87
    2	78
    1	65
    4	65
    
    

    So, inserting the fifth student data in the priority queue.

    因此,在优先级队列中插入第五个学生数据。

    And thus as per our comparator, the priority queue will be now,

    因此,根据我们的比较器,优先级队列现在为

    3	87
    2	78
    5	78
    1	65
    4	65
    
    

    So after popping we will get student list as,

    因此,弹出后,我们将获得学生名单,

    3 87
    2 78
    5 78
    1 65
    4 65
    
    

    优先级队列的用户定义比较器的C ++实现 (C++ implementation for user-defined comparator for priority queue)

    #include <bits/stdc++.h>
    using namespace std;
    
    class student {
    public:
        int roll;
        int marks;
        student()
        {
            roll = 0;
            marks = 0;
        }
    };
    
    void sort_students(vector<student> arr)
    {
        //comparator lambda function
        auto comp = [](student a, student b) {
            //comparison logic
            if (a.marks > b.marks)
                return false;
            else if (a.marks < b.marks)
                return true;
            else { // when marks are same
                if (a.roll < b.roll) {
                    return false;
                }
                else
                    return true;
            }
        };
    
        priority_queue<student, vector<student>, decltype(comp)> pq(comp);
    
        for (auto& ij : arr) {
            pq.push(ij);
        }
        //printing the sorted list
        cout << "roll marks\n";
        while (!pq.empty()) {
            cout << pq.top().roll << " " << pq.top().marks << endl;
            pq.pop();
        }
    }
    
    int main()
    {
    
        int n;
        
        cout << "Enter number of students\n";
        cin >> n;
        
        vector<student> arr(n);
        cout << "Enter roll and marks for each student\n";
        for (int i = 0; i < n; i++) {
            int x, y;
            cin >> x >> y;
            arr[i].roll = x;
            arr[i].marks = y;
        }
        
        cout << "sorting students according to marks and roll no: \n";
        
        sort_students(arr);
        
        return 0;
    }
    
    

    Output:

    输出:

    Enter number of students
    5
    Enter roll and marks for each student
    1 65
    2 78
    3 87
    4 65
    5 78
    sorting students according to marks and roll no: 
    roll marks
    3 87
    2 78
    5 78
    1 65
    4 65
    
    
    

    翻译自: https://www.includehelp.com/stl/user-defined-comparator-for-priority-queue-in-cpp-stl.aspx

    stl优先队列定义>可以吗

    展开全文
  • 默认的优先队列是个极大堆,如果要改变优先队列中元素的优先级,有下面这些方法 struct cmp1 { bool operator ()(int &amp;amp;a,int &amp;amp;b) { return a&amp;gt;b;//最小值优先 } ...

    转载自https://blog.csdn.net/queuelovestack/article/details/47661029
    默认的优先队列是个极大堆,如果要改变优先队列中元素的优先级,有下面这些方法

        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.按照从大到小进行排序 priority_queue<int>q1; priority_queue<int,vector<int>,less<int> >q2;//注意less<int>和最后一个>要加空格分隔开 ...priority_queue<
  • 默认优先级是从大到小. 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 &...
  • 优先队列

    2020-02-01 17:38:42
    优先队列定义 普通队列是一种先入先出得数据结构。 而在优先队列中元素被赋予优先级。当访问元素得时候,具有最高优先级得元素最先删除。 定义方式priority_queue<int ,vector<int>,cmp, >que;//第一个...
  • FIFO队列和优先队列

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

    2019-10-25 10:15:39
    1.优先队列定义 #define MAXSIZE 11 //队列的最大容量 typedef int DataType; //int的别名(队列中的元素类型) //单链表(结点结构) typedef struct _QNode { //每个节点的优先级,0最低优先级(自定义,可更改),9...
  • 定义方式 priority_queue< node >qu;其中node为结构体; 意义 由于结构体中含多种不同类型的数据,要先定义结构体的小于号 代码 struct bing { int id; int you; bing(int id1,int you1) { id=id1; ...
  • 优先队列详解

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

    2020-01-24 10:49:07
    优先队列定义 堆及相关操作 STL中priority_queue有优先队列的相关操作 相关题目:Expedition
  • 顾名思义,优先队列将数据按优先级顺序排列。一个优先队列由许多有序的元素构成,优先级最高的元素可以...优先队列的接口定义优先队列的基本接口包含,1、初始化优先队列;2、销毁优先队列;3、向优先队列中插入一个...
  • #include struct node { int l,r; bool operator <(const node &a)const { return r>a.r; } }; priority_queue<...当队列中需要按照某个值的大小来排列时,可以用这个;...队列定义 prio...
  • 优先队列:priority_queue 定义1:最简单。 priority_queue<int> q; 队列从头至尾,是从大到小。 定义2:结构体。 定义3:greater,less 从头到尾是递增的。 priority_queue<int,vector<int>,greater&...
  • 顺序优先队列定义

    2013-11-21 14:50:25
    #include #include using namespace std; template class SPQueue // 顺序优先级队列 { private: DataType *data; // 抽象类型DataType定义的指针数组 int size; // 队列的大

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,277
精华内容 910
关键字:

优先队列定义