优先队列用法

最新推荐文章于 2025-02-27 21:59:06 发布

转载最新推荐文章于 2025-02-27 21:59:06 发布 · 1.1k 阅读

文章标签：

#class #n2 #vector #less #c

转载同时被 2 个专栏收录

36 篇文章

订阅专栏

ACM_数据结构

8 篇文章

订阅专栏

本文详细介绍了 C++ 中 priority_queue 的基本使用方法，包括按照不同顺序进行排序的示例，以及如何处理结构体类型的元素。此外还讨论了如何自定义比较函数以支持指针类型的元素。

[转]priority_queue<int,vector<int>,greater<int>>优先队列按照由小到大顺序,

C++优先队列的基本使用方法
#include<iostream>
#include<functional>
#include<queue>
using namespace std;

struct node
{
    friend bool operator< (node n1, node n2)
    {
        return n1.priority < n2.priority;//"<"为从大到小排列，">"为从小打到排列
    }
    int priority;
    int value;
};

int main()
{
    const int len = 5;
    int i;
    int a[len] = {3,5,9,6,2};
    //示例1
    priority_queue<int> qi;//普通的优先级队列，按从大到小排序
    for(i = 0; i < len; i++)
        qi.push(a[i]);
    for(i = 0; i < len; i++)
    {
        cout<<qi.top()<<" ";
        qi.pop();
    }
    cout<<endl;

    //示例2
    priority_queue<int, vector<int>, greater<int> > qi2;//从小到大的优先级队列，可将greater改为less，即为从大到小
    for(i = 0; i < len; i++)
        qi2.push(a[i]);
    for(i = 0; i < len; i++)
    {
        cout<<qi2.top()<<" ";
        qi2.pop();
    }
    cout<<endl;

    //示例3
    priority_queue<node> qn;//必须要重载运算符
    node b[len];
    b[0].priority = 6; b[0].value = 1;
    b[1].priority = 9; b[1].value = 5;
    b[2].priority = 2; b[2].value = 3;
    b[3].priority = 8; b[3].value = 2;
    b[4].priority = 1; b[4].value = 4;

    for(i = 0; i < len; i++)
        qn.push(b[i]);
    cout<<"优先级"<<'\t'<<"值"<<endl;
    for(i = 0; i < len; i++)
    {
        cout<<qn.top().priority<<'\t'<<qn.top().value<<endl;
        qn.pop();
    }
    return 0;
}

对于队列里元素为一个结构体类型，按照某一个属性排序，就需要对比较函数进行重载

小结一下：

1、若是定义值类型对象，如：

int
main()
{
priority_queue<node> qn;

    node n1;
    n1.a = 9;
    node n2;
    n2.a = 2;
    node n3;
    n3.a = 50;

qn.push(n1);

qn.push(n2);

qn.push(n3);

int size = qn.size();

     for ( int i = 0; i < size; i++)
    {
        cout << qn.top().a << endl;

qn.pop();
}
return 0;

}
则定义优先级的时候，直接在类中写个friend 的操作符重载函数即可：

class node
{
public :
int a;

    node(){}
    node( int x):a(x){}
friend   bool operator<( const node ne1, const node ne2)//参数也可以为引用，值传递
    {
         if (ne1.a > ne2.a)
        {
             return   true ;
        }
         else
        {
             return   false ;
        }
    }
};
其中在c＋＋primer第三版中文版中关于操作符重载有如下描述：

"程序员只能为类类型或枚举类型的操作数定义重载操作符我们可以这样来实现把重
载操作符声明为类的成员或者声明为名字空间成员同时至少有一个类或枚举类型的参数
按值传递或按引用传递"

因此不可用指针类型的参数；

2、如果想定义一个指针类型的优先队列，那就不可这么简单的定义了，你需要自定义一个自己的比较函数，在priority_queue的模板函数中，我们可以利用这样一个template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type> >模板，在我们的程序代码中，则需要自己定义一个类来定义第三个模板参数，如：

class nodePointerComparer
{
public :
    nodePointerComparer(){}
     bool operator ()( const node* ne1, const node* ne2) const
    {
         return ne1->lessthan(ne2);
    }
};

当然在这之前我们的类Node要重新书写

class node
{
public :
     int a;
    node(){}
    node( int x):a(x){}

     bool lessthan( const node* pnode) const
    {
         return a < pnode->a;
    }
};
这样在main函数中就可以定义指针类型的优先队列了：

int main()
{
    priority_queue <node*, vector <node*>, nodePointerComparer> qn;
    node *n1 = new node(90);
    node *n2 = new node(2);
    node *n3 = new node(50);

qn.push(n1);
qn.push(n2); /span>

>
qn.push(n3);

     int size = qn.size();
     for ( int i = 0; i < size; i++)
    {
        cout << qn.top()->a << endl;
        qn.pop();
    }
     return 0;

}
疑问之处：如果你使用第一种值传递的操作符重载，来实现第二种的指针类型优先队列，是不会达到想要的结果的，个人理解是因为在指针类型的优先队列中找“<”运算符的时候，重载的不是我们写的值传递friend bool operator<(const node ne1,const node ne2)//

也就是没有找到指针类型的"<"重载，所有不会达到优先队列的效果。