`priority_queue` 类

容器适配器，用于维护顶部始终可访问最大（或最高优先级）元素的元素集合。可以添加新元素并删除或检查顶部元素，但不能直接访问集合中间的元素。

语法

template <class Type, class Container= vector <Type>, class Compare= less <typename Container ::value_type>>
class priority_queue

参数

Type
要存储在 . 中的 priority_queue元素数据类型。

Container
存储元素 priority_queue的基础容器的类型。

Compare
该类型提供一个函数对象，该对象将两个元素值作为排序键进行比较以确定其相对顺序 priority_queue。该参数可选。二进制谓词 less<typename Container::value_type> 是默认值。

注解

在对象的第一个priority_queue模板参数中指定的类Type元素等效value_type，并且必须与第二个模板参数指定的基础容器类Container中的元素类型匹配。 Type必须可分配，这意味着你可以复制该类型的对象，并将值分配给该类型的变量。

该 priority_queue 函数使用比较函数来确定哪些元素具有更高的优先级。此比较函数是类 Traits的函数对象。若要使用 priority_queue，元素只需支持使用小于运算符（<）的比较，以便它可以按顺序排列元素。

可以更改由 <a0/a0> 使用的基础容器类型。出于性能原因，可能需要执行此作。默认值 vector通常最适合缓存区域，因为元素存储在连续存储中，并且随着分配的增长而减少。但是，如果你拥有非常大或未绑定的队列，并且移动元素的成本很高，也许你会考虑 deque 一下。有关合适的基础容器类的详细信息，请参阅 container_type。

在两者 priority_queue 中添加和删除元素具有对数复杂性。访问 priority_queue 中的元素存在恒定的复杂性。

C++标准库定义了可用于将元素存储在以下 priority_queue位置的其他容器适配器： stack、 queue和 priority_queue：

stack 类支持后进先出 (LIFO) 数据结构。考虑板堆栈：只能插入、检查或删除堆栈顶部的元素（板），这是基容器末尾的最后一个元素。
queue 类支持先进先出 (FIFO) 数据结构。考虑一行中的人员。将元素（people）添加到行的后面，并将其从线条的前面删除。可以检查线条的前面和后面。
该 priority_queue 类对其元素进行排序，以便最大元素始终位于顶部。它支持元素的插入以及顶部元素的检查和删除。

构造函数

构造函数	说明
`priority_queue`	构造一个 `priority_queue`，它是空的，或者是一定范围内的基容器对象或其他 `priority_queue` 的副本。

Typedef

类型名称	说明
`container_type`	一种类型，它提供适应 `priority_queue` 的基础容器。
`size_type`	可表示 `priority_queue` 中元素数量的无符号整数类型。
`value_type`	一种类型，它表示存储为 `priority_queue` 中元素的对象的类型。

成员函数

成员函数	说明
`empty`	测试 `priority_queue` 是否为空。
`pop`	从顶部位置移除 `priority_queue` 的最大元素。
`push`	基于来自 `operator<` 的元素的优先级将元素添加到优先级队列。
`size`	返回 `priority_queue` 中的元素数量。
`top`	返回对 `priority_queue` 顶部的最大元素的常量引用。

要求

标头：<queue>

命名空间：std

`priority_queue::container_type`

一种类型，它提供将调整的基容器。

typedef Container container_type;

注解

该类型是模板参数 Container 的同义词。

适合priority_queue用于包括deque类、默认vector类或任何其他支持作frontpush_backpop_back的序列容器以及随机访问迭代器的基础容器类。容器适配器封装基础容器类，仅公开一组有限的序列容器成员函数作为公共接口。

有关如何声明和使用 container_type的示例，请参阅使用自定义容器和比较器

`priority_queue::empty`

测试 priority_queue 是否为空。

bool empty() const;

返回值

如果 true 为空，则返回 priority_queue；如果 false 不为空，则返回 priority_queue。

示例：检查是否为 `priority_queue` 空

// compile with: /EHsc
#include <queue>
#include <iostream>

int main()
{
   using namespace std;

   // Declares priority_queues with default deque base container
   priority_queue <int> q1, s2;

   q1.push(1);

   if (q1.empty())
      cout << "The priority_queue q1 is empty." << endl;
   else
      cout << "The priority_queue q1 is not empty." << endl;

   if (s2.empty())
      cout << "The priority_queue s2 is empty." << endl;
   else
      cout << "The priority_queue s2 is not empty." << endl;
}

The priority_queue q1 is not empty.
The priority_queue s2 is empty.

`priority_queue::pop`

从顶部位置移除 priority_queue 的最大元素。

void pop();

注解

priority_queue必须为 nonempty 才能使用此成员函数。顶部 priority_queue 始终包含容器中最大的元素。

示例：Pop 元素和检查大小

// compile with: /EHsc
#include <queue>
#include <iostream>

int main()
{
   using namespace std;
   priority_queue <int> q1, s2;

   q1.push(10);
   q1.push(20);
   q1.push(30);

   priority_queue <int>::size_type i, iii;
   i = q1.size();
   cout << "The priority_queue length is " << i << "." << endl;

   const int& ii = q1.top();
   cout << "The element at the top of the priority_queue is " << ii << "." << endl;

   q1.pop();

   iii = q1.size();
   cout << "After a pop, the priority_queue length is " << iii << "." << endl;

   const int& iv = q1.top();
   cout << "After a pop, the element at the top of the " << "priority_queue is " << iv << "." << endl;
}

The priority_queue length is 3.
The element at the top of the priority_queue is 30.
After a pop, the priority_queue length is 2.
After a pop, the element at the top of the priority_queue is 20.

`priority_queue::priority_queue`

创建一个 priority_queue 为空或从基本容器对象或从另一个 priority_queue容器对象复制范围。

priority_queue();

explicit priority_queue(const Traits& _comp);

priority_queue(const Traits& _comp, const container_type& _Cont);

priority_queue(const priority_queue& right);

template <class InputIterator>
priority_queue(InputIterator first, InputIterator last);

template <class InputIterator>
priority_queue(InputIterator first, InputIterator last, const Traits& _comp);

template <class InputIterator>
priority_queue(InputIterator first, InputIterator last, const Traits& _comp, const container_type& _Cont);

参数

_comp
constTraits 类型的比较函数用于对 priority_queue 中的元素进行排序，它默认为基容器的比较函数。

_Cont
所构造 priority_queue 要作为其副本的基容器。

right
所构造集要作为其副本的 priority_queue。

first
要复制的范围元素中的第一个元素的位置。

last
要复制的元素范围以外的第一个元素的位置。

注解

前三个构造函数中的每个函数均指定空的初始 priority_queue，第二个函数还指定用于建立元素顺序的比较函数 (comp) 的类型，第三个函数明确指定要使用的 container_type (_Cont)。关键字 explicit 取消了某些种类的自动类型转换。

第四个构造函数指定 priority_queue right 的副本。

最后三个构造函数复制某些容器的范围 [first, last)，并使用该值来初始化 priority_queue，同时增加了指定 Traits 和 container_type 类的比较函数的类型的明确性。

示例：使用自定义容器和比较器

// compile with: /EHsc
#include <queue>
#include <vector>
#include <deque>
#include <list>
#include <iostream>

int main()
{
   using namespace std;

   // Declares a priority_queue with a default vector base container
   priority_queue <int> q1;
   cout << "q1 = ( ";
   while (!q1.empty())
   {
      cout << q1.top() << " ";
      q1.pop();
   }
   cout << ")" << endl;

   // Declares a priority_queue with nondefault deque base container
   priority_queue <int, deque <int>> q2;
   q2.push(5);
   q2.push(15);
   q2.push(10);
   cout << "q2 = ( ";
   while (!q2.empty())
   {
      cout << q2.top() << " ";
      q2.pop();
   }
   cout << ")" << endl;
   cout << "After printing, q2 has " << q2.size() << " elements." << endl;

   // Declares a priority_queue with a vector base container and specifies that
   // the comparison function greater is to be used for ordering elements
   priority_queue <int, vector<int>, greater<int>> q3;
   q3.push(2);
   q3.push(1);
   q3.push(3);
   cout << "q3 = ( ";
   
   while (!q3.empty())
   {
      cout << q3.top() << " ";
      q3.pop();
   }
   cout << ")" << endl;

   // Declares a priority_queue and initializes it with elements copied from another
   // container by first inserting elements into q1 and then copying q1 elements into q4
   q1.push(100);
   q1.push(200);
   priority_queue <int> q4(q1);
   cout << "q4 = ( ";
   while (!q4.empty())
   {
      cout << q4.top() << " ";
      q4.pop();
   }
   cout << ")" << endl;

   // Creates an auxiliary vector object v5 to be used to initialize q5
   vector <int> v5;
   vector <int>::iterator v5_Iter;
   v5.push_back(10);
   v5.push_back(30);
   v5.push_back(20);
   cout << "v5 = ( " ;
   for (v5_Iter = v5.begin() ; v5_Iter != v5.end() ; v5_Iter++)
   {
      cout << *v5_Iter << " ";
   }
   cout << ")" << endl;

   // Declares and initializes a priority_queue q5 by copying the
   // range v5[ first,  last) from vector v5
   priority_queue <int> q5(v5.begin(), v5.begin() + 2);
   cout << "q5 = ( ";
   while (!q5.empty())
   {
      cout << q5.top() << " ";
      q5.pop();
   }
   cout << ")" << endl;

   // Declares a priority_queue q6 with a comparison function greater and
   // initializes q6 by copying the range v5[ first,  last) from vector v5
   priority_queue <int, vector<int>, greater<int>> q6(v5.begin(), v5.begin() + 2);
   cout << "q6 = ( ";
   while (!q6.empty())
   {
      cout << q6.top() << " ";
      q6.pop();
   }
   cout << ")" << endl;
}

`priority_queue::push`

基于来自 operator< 的元素的优先级将元素添加到优先级队列。

void push(const Type& val);

参数

val
要添加到顶部的 priority_queue元素。

注解

顶部 priority_queue 包含容器中最大的元素。

示例：推送元素并读取顶部

// compile with: /EHsc
#include <queue>
#include <iostream>

int main()
{
   using namespace std;
   priority_queue<int> q1;

   q1.push(10);
   q1.push(30);
   q1.push(20);

   priority_queue<int>::size_type i;
   i = q1.size();
   cout << "The priority_queue length is " << i << "." << endl;

   const int& ii = q1.top();
   cout << "The element at the top of the priority_queue is " << ii << "." << endl;
}

The priority_queue length is 3.
The element at the top of the priority_queue is 30.

`priority_queue::size`

返回 priority_queue 中的元素数量。

size_type size() const;

返回值

priority_queue 的当前长度。

示例：获取中的元素数

// compile with: /EHsc
#include <queue>
#include <iostream>

int main()
{
   using namespace std;
   priority_queue <int> q1, q2;
   priority_queue <int>::size_type i;

   q1.push(1);
   i = q1.size();
   cout << "The priority_queue length is " << i << "." << endl;

   q1.push(2);
   i = q1.size();
   cout << "The priority_queue length is now " << i << "." << endl;
}

The priority_queue length is 1.
The priority_queue length is now 2.

`priority_queue::size_type`

一个表示元素数的 priority_queue无符号整数类型。

typedef typename Container::size_type size_type;

注解

此类型是适应的基础容器priority_queue的同义词size_type。

示例：访问顶部元素

有关如何声明和使用 size_type的示例，请参阅获取元素数

`priority_queue::top`

返回对 priority_queue 顶部的最大元素的常量引用。

const_reference top() const;

返回值

对由 Traits 的对象 priority_queue 函数确定的最大元素的引用。

注解

priority_queue必须为 nonempty 才能使用此成员函数。

示例：获取的顶部元素 `priority_queue`

// compile with: /EHsc
#include <queue>
#include <iostream>

int main()
{
   using namespace std;
   priority_queue<int> q1;

   q1.push(10);
   q1.push(30);
   q1.push(20);

   priority_queue<int>::size_type i;
   i = q1.size();
   cout << "The priority_queue length is " << i << "." << endl;

   const int& ii = q1.top();
   cout << "The element at the top of the priority_queue is " << ii << "." << endl;
}

The priority_queue length is 3.
The element at the top of the priority_queue is 30.

`priority_queue::value_type`

一种类型，它表示存储为 priority_queue 中元素的对象的类型。

typedef typename Container::value_type value_type;

注解

此类型是适应的基础容器priority_queue的同义词value_type。

示例：使用priority_queue value_type别名

// compile with: /EHsc
#include <queue>
#include <iostream>

int main()
{
   using namespace std;

   // Declares priority_queues with default deque base container
   priority_queue<int>::value_type AnInt;

   AnInt = 69;
   cout << "The value_type is AnInt = " << AnInt << endl;

   priority_queue<int> q1;
   q1.push(AnInt);
   cout << "The element at the top of the priority_queue is " << q1.top() << "." << endl;
}

The value_type is AnInt = 69
The element at the top of the priority_queue is 69.

示例：使用用户定义的数据类型

若要与用户定义的类型元素一起使用 priority_queue ，必须提供比较元素的方法。可以为类型定义 operator< 或提供自定义比较函数对象。

以下示例演示了一个 priority_queue 存储 Task 按优先级排序的对象。优先级较高的任务位于队列的顶部。

// compile with: /EHsc
#include <queue>
#include <iostream>
#include <string>

struct Task
{
    int priority;
    std::string name;

    // Define operator< for priority_queue ordering
    // Returns true if this task has LOWER priority than other
    // (priority_queue puts the "largest" element at the top)
    bool operator<(const Task& other) const
    {
        return priority < other.priority;
    }
};

int main()
{
    std::priority_queue<Task> tasks;

    tasks.push({3, "Low priority task"});
    tasks.push({10, "High priority task"});
    tasks.push({5, "Medium priority task"});

    std::cout << "Processing tasks by priority:\n";
    while (!tasks.empty())
    {
        const Task& t = tasks.top();
        std::cout << "  Priority " << t.priority << ": " << t.name << "\n";
        tasks.pop();
    }
}

Processing tasks by priority:
  Priority 10: High priority task
  Priority 5: Medium priority task
  Priority 3: Low priority task

注解

如果需要不同的排序（例如，首先降低值），请提供自定义比较器：

struct ComparePriority
{
    bool operator()(const Task& a, const Task& b)
    {
        return a.priority > b.priority; // Lower priority value means higher priority
    }
};

std::priority_queue<Task, std::vector<Task>, ComparePriority> minQueue;

另请参阅

C++ 标准库中的线程安全
 C++ 标准库参考

反馈

此页面是否有帮助？

Last updated on 2026-01-19

通过

priority_queue 类

语法

参数

注解

例子

构造函数

Typedef

成员函数

要求

priority_queue::container_type

注解

priority_queue::empty

返回值

示例：检查是否为 priority_queue 空

priority_queue::pop

注解

示例：Pop 元素和检查大小

priority_queue::priority_queue

参数

注解