C++_STL——queue（and priority_queue）

最新推荐文章于 2024-05-09 08:53:41 发布
最新推荐文章于 2024-05-09 08:53:41 发布
阅读量400 收藏
点赞数 1
分类专栏： cplusplus——STL笔记 文章标签： c++ 自动驾驶
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asdasdde/article/details/120289625
版权

C++_STL——queue（and priority_queue）

queue：

template <class T, class Container = deque<T> > class queue;

先进先出队列

参数：

T:元素类型

Container：存储元素的内部底层容器对象的类型。

1、构造函数std::queue::queue

initialize (1)explicit queue (const container_type& ctnr);
move-initialize (2)explicit queue (container_type&& ctnr = container_type());
allocator (3)template <class Alloc> explicit queue (const Alloc& alloc);
init + allocator (4)template <class Alloc> queue (const container_type& ctnr, const Alloc& alloc);
move-init + allocator (5)template <class Alloc> queue (container_type&& ctnr, const Alloc& alloc);
copy + allocator (6)template <class Alloc> queue (const queue& x, const Alloc& alloc);
move + allocator (7)template <class Alloc> queue (queue&& x, const Alloc& alloc);

1.1功能

1、初始化构造函数 ：

​ 构造一个容器适配器，其内部容器被初始化为 ctnr 的副本。

2、移动初始化构造函数 ：

​ 构造一个容器适配器，其内部容器通过移动构造它来获取 ctnr 的值。

3、分配器构造函数 ：

​ 构造一个容器适配器，其内部容器是用 alloc 作为参数构造的。

4、用分配器构造函数初始化 ：

​ 构造一个容器适配器，其内部容器是用 cntr 和 alloc 作为参数构造的。

5、使用分配器构造函数进行移动初始化:

​ 构造一个容器适配器，其内部容器是用 std::move(cntr) 和 alloc 作为参数构造的。

6、用分配器构造函数复制:

​ 构造一个容器适配器，其内部容器是用 x 的内部容器作为第一个参数和 alloc 作为第二个参数来构造的。

7、 用分配器构造函数移动：

​ 构造一个容器适配器，它的内部容器是通过移动 x 的内部容器作为第一个参数并传递 alloc 作为第二个参数来构造的。

// constructing queues
#include <iostream>       // std::cout
#include <deque>          // std::deque
#include <list>           // std::list
#include <queue>          // std::queue

int main ()
{
  std::deque<int> mydeck (3,100);        // deque with 3 elements
  std::list<int> mylist (2,200);         // list with 2 elements

  std::queue<int> first;                 // empty queue
  std::queue<int> second (mydeck);       // queue initialized to copy of deque

  std::queue<int,std::list<int> > third; // empty queue with list as underlying container
  std::queue<int,std::list<int> > fourth (mylist);

  std::cout << "size of first: " << first.size() << '\n';
  std::cout << "size of second: " << second.size() << '\n';
  std::cout << "size of third: " << third.size() << '\n';
  std::cout << "size of fourth: " << fourth.size() << '\n';

  return 0;
}

2、std::queue::back

reference& back();
const_reference& back() const;

2.1功能

返回对队列中最后一个元素的引用。 这是队列中的“最新”元素（即推入队列的最后一个元素）。

2.2返回值

对队列中最后一个元素的引用。

// queue::back
#include <iostream>       // std::cout
#include <queue>          // std::queue

int main ()
{
  std::queue<int> myqueue;

  myqueue.push(12);
  myqueue.push(75);   // this is now the back

  myqueue.back() -= myqueue.front();

  std::cout << "myqueue.back() is now " << myqueue.back() << '\n';

  return 0;
}

3、std::queue::emplace

template <class... Args> void emplace (Args&&... args);

3.1功能

在队列的末尾添加一个新元素，在其当前最后一个元素之后。 这个新元素是通过 args 作为其构造函数的参数就地构造的。

3.2参数

构造函数参数

// queue::emplace
#include <iostream>       // std::cin, std::cout
#include <queue>          // std::queue
#include <string>         // std::string, std::getline(string)

int main ()
{
  std::queue<std::string> myqueue;

  myqueue.emplace ("First sentence");
  myqueue.emplace ("Second sentence");

  std::cout << "myqueue contains:\n";
  while (!myqueue.empty())
  {
    std::cout << myqueue.front() << '\n';
    myqueue.pop();
  }

  return 0;
}

4、std::queue::empty

bool empty() const;

4.1功能

判断队列是否为空

4.2返回值

如果底层容器的大小为 0，则为 true，否则为 false。

// queue::empty
#include <iostream>       // std::cout
#include <queue>          // std::queue

int main ()
{
  std::queue<int> myqueue;
  int sum (0);

  for (int i=1;i<=10;i++) myqueue.push(i);

  while (!myqueue.empty())
  {
     sum += myqueue.front();
     myqueue.pop();
  }

  std::cout << "total: " << sum << '\n';

  return 0;
}

5、std::queue::front

 reference& front();
const_reference& front() const;

5.1功能

返回队头元素的引用

5.2返回值

队头元素的引用

// queue::front
#include <iostream>       // std::cout
#include <queue>          // std::queue

int main ()
{
  std::queue<int> myqueue;

  myqueue.push(77);
  myqueue.push(16);

  myqueue.front() -= myqueue.back();    // 77-16=61

  std::cout << "myqueue.front() is now " << myqueue.front() << '\n';

  return 0;
}

6、std::queue::pop

void pop();

6.1功能

弹出队头元素，删除队列中的队头元素，有效地将其大小减一。

// queue::push/pop
#include <iostream>       // std::cin, std::cout
#include <queue>          // std::queue

int main ()
{
  std::queue<int> myqueue;
  int myint;

  std::cout << "Please enter some integers (enter 0 to end):\n";

  do {
    std::cin >> myint;
    myqueue.push (myint);
  } while (myint);

  std::cout << "myqueue contains: ";
  while (!myqueue.empty())
  {
    std::cout << ' ' << myqueue.front();
    myqueue.pop();
  }
  std::cout << '\n';

  return 0;
}

7、std::queue::push

void push (const value_type& val);
void push (value_type&& val);

7.1功能

在队列的末尾插入一个新元素，在其当前最后一个元素之后。 这个新元素的内容被初始化为 val。 这个成员函数有效地调用了底层容器对象的成员函数 push_back。

7.2参数

插入元素的初始化值。

// queue::push/pop
#include <iostream>       // std::cin, std::cout
#include <queue>          // std::queue

int main ()
{
  std::queue<int> myqueue;
  int myint;

  std::cout << "Please enter some integers (enter 0 to end):\n";

  do {
    std::cin >> myint;
    myqueue.push (myint);
  } while (myint);

  std::cout << "myqueue contains: ";
  while (!myqueue.empty())
  {
    std::cout << ' ' << myqueue.front();
    myqueue.pop();
  }
  std::cout << '\n';

  return 0;
}

8、std::queue::size

size_type size() const;

8.1功能

返回底层容器的大小

8.2返回值

底层容器的大小

// queue::size
#include <iostream>       // std::cout
#include <queue>          // std::queue

int main ()
{
  std::queue<int> myints;
  std::cout << "0. size: " << myints.size() << '\n';

  for (int i=0; i<5; i++) myints.push(i);
  std::cout << "1. size: " << myints.size() << '\n';

  myints.pop();
  std::cout << "2. size: " << myints.size() << '\n';

  return 0;
}

9、std::queue::swap

void swap (queue& x) noexcept(/*see below*/);

9.1功能

交换本底层容器与x底层容器的内容

// queue::swap
#include <iostream>       // std::cout
#include <queue>          // std::queue

int main ()
{
  std::queue<int> foo,bar;
  foo.push (10); foo.push(20); foo.push(30);
  bar.push (111); bar.push(222);

  foo.swap(bar);

  std::cout << "size of foo: " << foo.size() << '\n';
  std::cout << "size of bar: " << bar.size() << '\n';

  return 0;
}

priority_queue：

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

优先队列

经过专门设计，根据一些严格的弱排序标准，它的第一个元素始终是它包含的元素中最大的元素。满足Compare的在队尾，不满足的在队头，所以默认Compare = less，即a<b b在队头，a在队尾

参数：

T:元素的类型。

Container：存储元素的内部底层容器对象的类型。

Compare：比较类型一元谓词，与函数调用的比较函数不一样，这个可以说是伪函数或者仿函数，是类的一种

注意不要和构造函数参数搞混

1、构造函数

initialize (1)priority_queue (const Compare& comp, const Container& ctnr);
range (2)template <class InputIterator> priority_queue (InputIterator first, InputIterator last, const Compare& comp, const Container& ctnr);
move-initialize (3)explicit priority_queue (const Compare& comp = Compare(),
Container&& ctnr = Container());
move-range (4)template <class InputIterator> priority_queue (InputIterator first, InputIterator last, const Compare& comp, Container&& ctnr = Container());
allocator versions (5)template explicit priority_queue (const Alloc& alloc);
template priority_queue (const Compare& comp, const Alloc& alloc);
template priority_queue (const Compare& comp, const Container& ctnr, const Alloc& alloc);
template priority_queue (const Compare& comp, Container&& ctnr, const Alloc& alloc);
template priority_queue (const priority_queue& x, const Alloc& alloc);
template priority_queue (priority_queue&& x, const Alloc& alloc);

1.1参数

comp:用于对堆排序的比较对象。

ctnr :容器对象。

first,last: 将迭代器输入到序列中的初始位置和最终位置。 这个序列中的元素在排序之前被插入到底层容器中。

// constructing priority queues
#include <iostream>       // std::cout
#include <queue>          // std::priority_queue
#include <vector>         // std::vector
#include <functional>     // std::greater

class mycomparison
{
  bool reverse;
public:
  mycomparison(const bool& revparam=false)
    {reverse=revparam;}
  bool operator() (const int& lhs, const int&rhs) const
  {
    if (reverse) return (lhs>rhs);
    else return (lhs<rhs);
  }
};

int main ()
{
  int myints[]= {10,60,50,20};

  std::priority_queue<int> first;
  std::priority_queue<int> second (myints,myints+4);
  std::priority_queue<int, std::vector<int>, std::greater<int> >
                            third (myints,myints+4);
  // using mycomparison:
  typedef std::priority_queue<int,std::vector<int>,mycomparison> mypq_type;

  mypq_type fourth;                       // less-than comparison
  mypq_type fifth (mycomparison(true));   // greater-than comparison

  return 0;
}

#include <functional>
#include <queue>
#include <vector>
#include <iostream>
 
template<typename T>
void print_queue(T q) { // NB: pass by value so the print uses a copy
    while(!q.empty()) {
        std::cout << q.top() << ' ';
        q.pop();
    }
    std::cout << '\n';
}
 
int main() {
    std::priority_queue<int> q;
 
    const auto data = {1,8,5,6,3,4,0,9,7,2};
 
    for(int n : data)
        q.push(n);
 
    print_queue(q);
 
    std::priority_queue<int, std::vector<int>, std::greater<int>>
        q2(data.begin(), data.end());
 
    print_queue(q2);
 
    // Using lambda to compare elements.
    auto cmp = [](double left, double right) { return (int)left<(int)right; };
    std::priority_queue<double, std::vector<double>, decltype(cmp) > q3;
    const auto data1 = {1.1,1.4,2.1,3.4,3.3,4.1,1.8,5.1,3.6,7.7};
    for(double n : data1)
        q3.push(n);
 
    print_queue(q3);
}

queue有的priority_queue都有，除了front

2、std::priority_queue::top

const_reference top() const;

2.1功能

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

2.2返回值

顶部元素的常量引用。

// priority_queue::top
#include <iostream>       // std::cout
#include <queue>          // std::priority_queue

int main ()
{
  std::priority_queue<int> mypq;

  mypq.push(10);
  mypq.push(20);
  mypq.push(15);

  std::cout << "mypq.top() is now " << mypq.top() << '\n';

  return 0;
}

参考：queue
295. 数据流的中位数 - 力扣（LeetCode） (leetcode-cn.com)

勿在浮沙築高臺
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ STL学习——queue
乞力马扎罗的雪CYF的博客
08-23 3710
我们在上一篇博客中《C++ STL学习——stack》简单介绍了STL 中stack这种数据结构的使用，这篇博客主要来讲一下queue队列的使用。其实queue的使用和stack一样简单。示例代码上传至 https://github.com/chenyufeng1991/STL_queue 。（1）首先要引入头文件  #include . 并使用命名空间  using namespace std
STL-queue--.rar_stl queue
09-24
STL队列常用于任务调度、消息传递、优先级队列（通过结合`priority_queue`实现）、网络缓冲区管理等场景。线段树则广泛应用于动态规划、几何问题、字符串处理等领域，对于需要高效处理区间数据的问题非常有用。 ...
STL之三：队列和queue，优先队列和priority_queue
霸霸的博客
08-08 195
队列是基本的数据结构之一，特点是“先进先出”。 头文件：#include<queue> 队列的有关操作如下： queue<Type> q; //定义队列，Type为数据类型 q.push(item); //把item放入队列 q.front(); //返回队首元素，但不会删除 q.pop(); //删除队首元素 q.back(); //返回队尾元素 q.s...
C++容器——queue
最新发布
2301_80158456的博客
05-09 289
C++的queue容器，使用和用法
c++ STL queue构造及方法
qq_42948022的博客
10-02 1115
#include <vector> #include <string> #include <iostream> #include <list> #include <iterator> #include <deque> #include <stack> #include <queue> #include ...
c++ queue容器函数说明
Mr____DAI的博客
03-16 192
不提供直接访问和修改元素的方法，因为它是一种先进先出的数据结构，只能从开头添加和删除元素。
queue emplace_S T L -stack/queue(C++)
weixin_39958138的博客
11-26 470
为了方便学习理解，先上两张图：1、基础认识stack/queue都是封装了deque<T>容器的适配器类模板,两者都没有迭代器，访问元素的唯一方式就是遍历内容器内容，同时移除访问过的每一个元素，应该说是想l遍历是必须移除，或者考虑拷贝到另一个容器中。 stack默认实现的是一个后入先出的压入栈（图一）；#include <stack> ...
STL.rar_C++ STL_C++ STL_STL_STL c++_STL教程
09-14
- 特殊容器如stack（栈）、queue（队列）和priority_queue（优先队列）的使用场景和操作方法。 - 泛型编程的概念，理解模板和模板函数在STL中的作用。 - STL容器和算法的性能分析，如时间复杂度和空间复杂度。 通过...
STL-70个算法.rar_C++_stl 练习
09-23
stack（栈）、queue（队列）和priority_queue（优先队列）是容器适配器，它们在原有数据结构的基础上提供了一种特定的操作接口，满足特定的抽象数据类型需求。 6. 迭代器适配器： 例如，反向迭代器（reverse_...
stl.zip_C++_STL
09-20
**C++ STL（Standard Template Library）详解** C++ STL 是 C++ 标准库中的一个重要组成部分，它提供了高效且灵活的容器、迭代器、算法和函数对象，极大地简化了 C++ 编程并提升了代码的可读性和复用性。在深入理解...
c++API.zip_-baijiahao_C++帮助文档_Load c++_STL库_stl API
09-20
6. 适配器：如stack、queue、priority_queue，它们将基础容器包装成特定的行为模式，如后进先出（LIFO）的栈、先进先出（FIFO）的队列和优先级队列。 在"C++API.chm"文件中，你可以找到关于这些组件的详细说明，...
STL priority_queue（优先队列）详解
09-01
STL中的`priority_queue`是一种特殊的容器适配器，它模拟了一个优先队列的数据结构。优先队列的主要特性是每次从队列头部取出的是具有最高优先级的元素，即最大值（默认情况下）。这个数据结构在很多算法和问题中都...
EffectiveSTL_STL_C++_experience_gas841_C++STL_
09-30
5. 特殊容器和组件：如stack（栈）、queue（队列）和priority_queue（优先队列）等，它们是基于现有容器实现的抽象数据类型，Meyers会指导读者如何有效地利用它们。 6. 模板元编程：Meyers还涉及了模板元编程这一...
Effective_STL.rar_STL_C/C++_
08-12
5. **容器适配器**：stack、queue和priority_queue是STL的容器适配器，它们分别基于deque、deque和set实现，提供了栈、队列和优先队列的行为。 6. **智能指针**：虽然不是STL的一部分，但shared_ptr、unique_ptr和...
C++_STL编程轻松入门.pdf
09-30
- **适配器（Adapters）**：改变容器或迭代器行为的工具，例如stack、queue、priority_queue等。 4. **STL的优势** - **复用性**：STL提供了一套标准的接口，程序员可以重用这些接口来实现不同的数据结构和算法，...
STL.rar_STL_STL PPT_iterator_stl p
09-21
STL，全称为Standard Template Library（标准模板库），是C++编程语言中不可或缺的一部分，它提供了高效且灵活的数据结构和算法。STL的核心思想是泛型编程，即编写不依赖于特定数据类型的代码，从而提高了代码的重用...
C++ STL标准库：std::queue 队列的使用 empty() size() front() back() push() emplace() pop() swap()
热门推荐
超级大洋葱的博客
12-17 1万+
#pragma warning(disable:4786) #include <iostream> #include <queue> #include <string> #include <list> #include <assert.h> using namespace std; void main43() { queue<string,list<string> > q1; q1.push("苹果"); c
数据结构之队列的定义及构造函数
weixin_30478923的博客
06-08 241
数据结构之队列 队列的定义 队列是一种特殊的线性表，只允许在表的头部进行删除操作，在表的尾部进行插入操作的线性数据结构，这种结构就叫做队列；另外其还有先进先出，后进后出的特征。 说到线性结构，得先了解一下数据的逻辑结构，数据的逻辑结构分为线性结构、集合结构、树形结构和图形结构，如下图所示，栈是一种特殊的线性表，是线性结构的一种。 JavaScript => 数据结构之队列结构的构造函...
队列与C++中的std::queue详解（多图超详细）
jianmo的博客
05-26 5006
队列就是一种线性的数据结构，它与日常生活中排队的队列相似，即先进先出（LIFO, First In First Out)，这点也是它与栈（Stack）的最大不同之处。它的结构类似于下面的容器：如上图所示，队列的结构就像一个两端都是开口的容器，一端只负责小球（对应队列中的元素）进入，一个端只负责小球弹出，容器内部的小球无法跳过前面的小球提前弹出。我们将队列的出口端（即队列的头部）叫做队头（front），入口端（即队列的末尾）称为队尾（rear）。
C++ STL priority_queue
08-30
- *1* *2* *3* [【总结】C++ 基础数据结构 —— STL之优先队列（priority_queue） 用法详解](https://blog.csdn.net/weixin_44668898/article/details/102132580)[target="_blank" data-report-click={"spm":"1018....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值