STL容器——优先队列

最新推荐文章于 2025-07-07 20:44:49 发布

Jeromiewn

最新推荐文章于 2025-07-07 20:44:49 发布

阅读量489

点赞数

CC 4.0 BY-SA版权

分类专栏： STL 优先队列基础学习文章标签： acm 模板算法 stl

本文链接：https://blog.youkuaiyun.com/Jeromiewn/article/details/52888415

基础学习同时被 3 个专栏收录

8 篇文章

订阅专栏

STL

5 篇文章

订阅专栏

优先队列

3 篇文章

订阅专栏

本文介绍了C++ STL中的优先队列，包括优先队列的基本概念、创建方式、不同类型优先级队列的定义，以及如何进行基本操作如empty、size、pop、top和push。还特别强调了对于自定义类型需要重载<运算符来设定优先级顺序。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

优先队列

在队列基础上按优先级顺序进入队列

0.头文件#include <queue>

greater和less的优先级比较（和自定义的作用一样），在头文件#include <functional>里

1.创建一个优先级队列时有两种申请方式：

priority_queue<ElemType>q或者priority_queue<ElemType,vector<ElemType>,greater<ElemType> >q，

第一种默认的东西比较多，比如底层的实现方式以及堆的性质；

第二种就说明的比较清晰了，第一个参数是队列中元素的类型；第二个就是队列底层的实现方式，这里是用vector实现的；第三个是堆的性质，greater对应小顶堆，less对应大顶堆，当然这两个只能适用于一些基本类型，于是优先级就是这些基本类型元素的大小。

如果遇到一些复杂的类型，比如结构体或类，那么就要重新定义这个优先级，于是便要重载bool operator()，或者重载<。

例如：

声明优先队列 priority_queue<int>q;//这是默认的优先级顺序

也可以直接对于结构体 priority_queue<node>q[10];//其中struct node{……};

（node n;//声明一个结构体再 p[b].push(n);//这一种直接将结构体压入队列中）

2.基本操作：

q.empty() 如果队列为空，则返回true，否则返回false

q.size() 返回队列中元素的个数

q.pop() 删除队首元素，但不返回其值

q.top() 返回具有最高优先级的元素值，但不删除该元素

q.push(item) 在基于优先级的适当位置插入新元素

3.除了默认的优先顺序，还可以自定义优先级比较

重载<运算符，重载的是优先级关系，理解一下这个：

struct node1
{
    int x;
    bool operator < (const node1 &n) const
    {
        return x>n.x;//最小值优先（先进先出）
    }

};
struct node3
{
    int x;
    friend bool operator <(node3 n1,node3 n2)//重载：n小的优先级高
    {
      return n1.x>n2.x;
    }
};

x>n.x; 和 n1.x>n2.x;一样，表示的是，n1.x<n2.x，n2的x小，对应的优先级高

就是重载 <

若a>b，表示小的优先级高

若a<b，表示大的优先级高

理解！记住啊。。

有时候出现其他约束条件

struct node4
{
    int pri;
    int num;
    friend bool operator <(node4 n1,node4 n2)//重载：含义是如果pri不同，则pri大的优先级高；如果相同，则看num，num小的优先级高
    {
        if(n1.pri==n2.pri) return n1.num>n2.num;
        else return n1.pri<n2.pri;
    }
};

看着dalao的说明自己敲了一下，受益匪浅！！

</pre><pre name="code" class="cpp">#include <iostream>
#include <queue>//优先队列头文件
#include <cstdio>
#include <functional>//含有greater 和 less，也可以自己定义cmp比较
using namespace std;
//第一种自定义数据结构
struct node1
{
    int x;
    bool operator < (const node1 &a) const
    {
        return x>a.x;//最小值优先（先进先出）
    }

};
struct node2
{
    int x;
    bool operator < (const node2 &a) const
    {
        return x<a.x;//最大值有先
    }
};
struct node3
{
    int x;
    friend bool operator <(node3 n1,node3 n2)//重载：含义是如果pri不同，则pri大的优先级高；如果相同，则看num，num小的优先级高
    {
      return n1.x>n2.x;
    }
};
//别的约数条件下，判断优先级
struct node4
{
    int pri;
    int num;
    friend bool operator <(node4 n1,node4 n2)//重载：含义是如果pri不同，则pri大的优先级高；如果相同，则看num，num小的优先级高
    {
        if(n1.pri==n2.pri) return n1.num>n2.num;
        else return n1.pri<n2.pri;
    }
};
//第二种定义比较结构
struct cmp1
{
    bool operator ()(int &a,int &b)
    {
        return a>b;//最小值优先
    }
};
struct cmp2
{
    bool operator ()(int &a,int &b)
    {
        return a<b;//最大值优先
    }
};
int a[]= {2,19,5,68,19,99,37,0,50,22};
node1 n1[]= {2,19,5,68,19,99,37,0,50,22};
node2 n2[]= {2,19,5,68,19,99,37,0,50,22};
node3 n3[]= {2,19,5,68,19,99,37,0,50,22};
int main()
{
    //默认优先级顺序
    priority_queue<int>que;
    //第一种
    priority_queue<node1>que1;
    priority_queue<node2>que2;
     priority_queue<node3>que33;
    //第二种(用自己构造的比较结构体)
    priority_queue<int,vector<int>,cmp1>que3;//最小值
    priority_queue<int,vector<int>,cmp2>que4;//最大值
    //第二种（自带的）
    priority_queue<int,vector<int>,greater<int> >que5;//和que3作用一样，最小值
    priority_queue<int ,vector<int>,less<int> >que6;//和que4作用一样，最大值

    //给所有优先队列赋初值
    for(int i=0; i<10; i++)
    {
        que1.push(n1[i]);
        que2.push(n2[i]);
        que33.push(n3[i]);
    }
    for(int i=0; i<10; i++)
    {
        que.push(a[i]);
        que3.push(a[i]);
        que4.push(a[i]);
        que5.push(a[i]);
        que6.push(a[i]);
    }

    //打印
    printf("采用默认优先级顺序:\npriority_queue<int>que;\n");
    while(!que.empty())
    {
        printf("%d ",que.top());
        que.pop();
    }
    printf("\n\n采用结构体自定义优先级方式一\npriority_queue<node1>que1;\n");
    while(!que1.empty())
    {
        printf("%d ",que1.top());
        que1.pop();
    }
    printf("\npriority_queue<node2>que2;\n");
    while(!que2.empty())
    {
        printf("%d ",que2.top());
        que2.pop();
    }
    printf("\n\n自定义优先级方式一加一：\n");
     while(!que33.empty())
    {
        printf("%d ",que33.top());
        que33.pop();
    }
    printf("\n\n采用结构体自定义优先级方式二 \npriority_queue<int,vector<int>,cmp1>que3;\n");
    while(!que3.empty())
    {
        printf("%d ",que3.top());
        que3.pop();
    }
    printf("\npriority_queue<int,vector<int>,cmp2>que4;\n");
    while(!que4.empty())
    {
        printf("%d ",que4.top());
        que4.pop();
    }
    printf("\n\n采用结构体自定义优先级方式二加一\n采用头文件/functional/内定义优先级:\n(priority_queue<int,vector<int>,greater<int>greater<int> >que5;\n");
    while(!que5.empty())
    {
        printf("%d ",que5.top());
        que5.pop();
    }
    printf("\n(priority_queue<int,vector<int>,greater<int>greater<int> >que6;\n");
    while(!que6.empty())
    {
        printf("%d ",que6.top());
        que6.pop();
    }
    printf("\n");

    /*
    采用默认优先级顺序:
    priority_queue<int>que;
    91 83 56 47 36 22 14 10 7 3

    采用结构体自定义优先级方式一（推荐）
    priority_queue<node1>que1;
    3 7 10 14 22 36 47 56 83 91
    priority_queue<node2>que2;
    91 83 56 47 36 22 14 10 7 3

    采用结构体自定义优先级方式二
    priority_queue<int,vector<int>,cmp1>que3;
    3 7 10 14 22 36 47 56 83 91
    priority_queue<int,vector<int>,cmp2>que4;
    91 83 56 47 36 22 14 10 7 3

    采用结构体自定义优先级方式二加一
    采用头文件/functional/内定义优先级:
    (priority_queue<int,vector<int>,greater<int>greater<int> >que5;
    3 7 10 14 22 36 47 56 83 91
    (priority_queue<int,vector<int>,greater<int>greater<int> >que6;
    91 83 56 47 36 22 14 10 7 3


    */

    return 0;
}