【C++ 学习 ⑭】- 详解 stack、queue 和 priority_queue 容器适配器

已于 2023-08-18 11:13:40 修改
阅读量224 收藏 1
点赞数
分类专栏： C++ 文章标签： c++ 学习 开发语言
于 2023-08-18 11:08:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/melonyzzZ/article/details/132357423
版权

目录

一、详解 C++ STL 容器适配器

1.1 - 什么是容器适配器？

1.2 - 容器适配器的种类

二、详解 C++ STL deque 容器

2.1 - deque 的原理介绍

2.2 - deque 的优缺点

三、详解 stack 容器适配器

3.1 - stack 的基本介绍

3.2 - stack 的成员函数

3.3 - stack 的模拟实现

四、详解 queue 容器适配器

4.1 - queue 的基本介绍

4.2 - queue 的成员函数

4.3 - queue 的模拟实现

五、详解 priority_queue 容器适配器

5.1 - priority_queue 的基本介绍

5.2 - priority_queue 的成员函数

5.3 - priority_queue 的模拟实现

 

 

一、详解 C++ STL 容器适配器

1.1 - 什么是容器适配器？

在详解什么是容器适配器之前，初学者首先要理解适配器的含义。

其实，容器适配器中的 "适配器"，和生活中常见的电源适配器中的 "适配器" 的含义非常接近。我们知道，无论是电脑、手机还是其它电器，充电时都无法直接使用 220V 的交流电，为了方便用户使用，各个电器厂商都会提供一个适用于自己产品的电源适配器，它可以将 220V 的交流电转换成适合电器使用的低压直流电。

具有多种功能的电源适配器，可以满足多种需求：

7440d4c74e8341098eca2cab820ef393.png

 

因此简单理解，容器适配器就是将不适用的序列式容器（包括 vector、deque 和 list）变得适用。容器适配器的底层即通过封装某个序列式容器，并重新组合该容器中包含的成员函数，使其满足特定场景的需要。

容器适配器本质上还是容器，只不过此容器类模板的实现，利用了大量其他基础容器类模板中已经写好的成员函数。当然，如果必要的话，容器适配器中也可以自创新的成员函数。

需要注意的是，STL 中的容器适配器，其内部使用的基础容器并不是固定的，用户可以在满足特定条件的多个基础容器中自由选择。

 

1.2 - 容器适配器的种类

STL 提供了 3 种容器适配器，分别为 stack 栈适配器、queue 队列适配器以及 priority_queue 优先权队列适配器：

容器适配器基础容器需要包含的成员函数满足条件的基础容器默认使用的基础容器
stackempty()、size()、back()、push_back()、pop_back()vector、deque、listdeque
queueempty()、size()、front()、back()、push_back()、pop_front()deque、listdeque
priority_queueempty()、size()、front()、push_back()、pop_back()vector、dequevector

因为删除 vector 容器的头部元素需要移动大量元素，效率较低，所以 vector 容器没有提供 pop_front 成员函数，因此其不能作为 queue 的基础容器。

因为 list 容器不支持随机访问，所以其不能作为 priority_queue 的基础容器。

由于不同的序列式容器其底层采用的数据结构不同，因此容器适配器的执行效率也不尽相同，但通常情况下，使用默认的基础容器即可。

 

 

二、详解 C++ STL deque 容器

2.1 - deque 的原理介绍

deque 是 double-ended queue 的缩写，又称双端队列容器。

deque 容器和 vector 容器有很多相似的地方，例如：deque 容器也擅长在序列尾部插入或删除元素（时间复杂度为 O(1) 常数阶），而不擅长在序列中间添加或删除元素。和 vector 不同的是，deque 还擅长在序列头部插入或删除元素，时间复杂度也为 O(1) 常数阶，并且更重要的一点是，deque 并不是连续的空间，而是由一段段小空间拼接而成的，实际 deque 类似于一个动态二维数组，其底层结构如下图所示：

‘

3b64b0bcf9c24d7b8047dc13b5e859dd.png

双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其 "整体连续" 以及随机访问的假象，重任就落在了 deque 的迭代器身上，因此 deque 的迭代器设计就比较复杂，如下图所示：

da192373c061412db5f8b549da0c217c.png

 

那 deque 是如何借助其迭代器维护其假象连续的结构呢？

d33463aca65f4b6ba1c1bd1188b94652.png

 

 

2.2 - deque 的优缺点

和 vector 相比，deque 的优点：在头部插入和删除元素时，不需要移动元素，效率较高，而且在扩容时，也不需要移动大量的元素。

和 list 相比，deque 的优点：空间利用率较高，不需要存储额外字段。

但是，deque 有一个致命缺点：不适合遍历，因为在遍历时，deque 的迭代器要频繁地去检测是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑 vector 和 list，deque 的应用场景并不多，而目前看到的一个应用就是，STL 用其作为 stack 和 queue 的默认基础容器，因为：

  1. stack 和 queue 不需要遍历（因此 stack 和 queue 没有迭代器），只需要在固定的一端或两端进行操作；

  2. 在 stack 元素增长时，deque 比 vector 的效率高（扩容时不需要移动大量元素）；queue 中的元素增长时，deque 不仅效率高，而且空间利用率高。

即利用了 deque 的优点，而完美地避开了其缺点。

 

 

三、详解 stack 容器适配器

3.1 - stack 的基本介绍

stack 以类模板的形式定义在 <stack> 头文件中，并位于 std 命名空间中。

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

stack 是一种容器适配器，专门设计用于在后进先出（LIFO，last-in first-out）的环境中使用，元素只能从容器的一端进行插入和删除。

 

526efcd1e4ae4708a6047aefe182f903.png

 

3.2 - stack 的成员函数

构造函数：

explicit stack(const container_type& ctnr = container_type());

注意：container_type 等价于 Container。

构造一个 stack 容器适配器对象。

empty：

bool empty() const;

size：

size_type size() const;

top：

      value_type& top();
const value_type& top() const;

push：

void push(const value_type& val);

pop：

void pop();

示例：

#include <iostream>
#include <stack>
using namespace std;
​
int main()
{
    stack<int> st;
    st.push(1);
    st.push(2);
    st.push(3);
    st.push(4);
    cout << st.size() << endl;  // 4
    while (!st.empty())
    {
        cout << st.top() << " ";
        st.pop();
    }
    // 4 3 2 1
    cout << endl;
    return 0;
}

 

3.3 - stack 的模拟实现

#pragma once
​
#include <deque>
​
namespace yzz
{
    template<class T, class Container = std::deque<T>>
    class stack
    {
    public:
        bool empty() const
        {
            return _ctnr.empty();
        }
​
        size_t size() const
        {
            return _ctnr.size();
        }
​
        T& top()
        {
            return _ctnr.back();
        }
​
        const T& top() const
        {
            return _ctnr.back();
        }
​
        void push(const T& val)
        {
            _ctnr.push_back(val);
        }
​
        void pop()
        {
            _ctnr.pop_back();
        }
    private:
        Container _ctnr;
    };
}

 

 

四、详解 queue 容器适配器

4.1 - queue 的基本介绍

queue 以类模板的形式定义在 <queue> 头文件中，并位于 std 命名空间中。

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

queue 是一种容器适配器，专门设计用于在先进先出（FIFO，first-in first-out）的环境中使用，元素只能从容器的一端插入，并从另一端删除。

1a98d7c9fbfe4fb8b8aff847b8871a41.png

 

 

4.2 - queue 的成员函数

构造函数：

explicit queue(const container_type& ctnr = container_type());

empty：

bool empty() const;

size：

size_type size() const;

front：

      value_type& front();
const value_type& front() const;

back：

      value_type& back();
const value_type& back() const;

push：

void push(const value_type& val);

pop：

void pop();

示例：

#include <iostreamm>
#include <queue>
using namespace std;
​
int main()
{
    queue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);
    q.push(4);
    cout << q.size() << endl;  // 4
    cout << q.front() << " " << q.back() << endl;  // 1 4
    while (!q.empty())
    {
        cout << q.front() << " ";
        q.pop();
    }
    // 1 2 3 4
    cout << endl;
    return 0;
}

 

4.3 - queue 的模拟实现

#pragma once
​
#include <deque>
​
namespace yzz
{
    template<class T, class Container = std::deque<T>>
    class queue
    {
    public:
        bool empty() const
        {
            return _ctnr.empty();
        }
​
        size_t size() const
        {
            return _ctnr.size();
        }
​
        T& front()
        {
            return _ctnr.front();
        }
​
        const T& front() const
        {
            return _ctnr.front();
        }
​
        T& back()
        {
            return _ctnr.back();
        }
​
        const T& back() const
        {
            return _ctnr.back();
        }
​
        void push(const T& val)
        {
            _ctnr.push_back(val);
        }
​
        void pop()
        {
            _ctnr.pop_front();
        }
    private:
        Container _ctnr;
    };
}

 

 

五、详解 priority_queue 容器适配器

5.1 - priority_queue 的基本介绍

priority_queue 以类模板的形式定义在<queue> 头文件中，并位于 std 命名空间中。

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

priority_queue 是一种容器适配器，其模拟的也是队列这种存储结构，即使用此容器适配器存储元素，只能从一进（称为队尾），从另一端出（称为队头），且每次只能访问 priority_queue 中位于队头的元素。

但是，priority_queue 容器适配器中元素的存和取，遵循的并不是 "first-in first-out"（先进先出）原则，而是 "first-in largest-out" 原则，即先进队列的元素不一定先出队列，而是优先级最大的元素先出队列。

priority_queuue 容器适配器的 "first-in largest-out" 特性，和它底层采用堆（heap）结构存储数据是分不开的，注意：priority_queue 默认情况下是大根堆。

 

5.2 - priority_queue 的成员函数

构造函数：

initialize (1) explicit priority_queue(const Compare& Cmp = Compare(), 
                                       const Container& ctnr = Container());
     range (2) template <class InputIterator>
               priority_queue(InputIterator first, InputIterator last,
                              const Compare& Cmp = Compare(), 
                              const Container& ctnr = Container()));

empty：

bool empty() const;

size：

size_type size() const;

top：

const value_type& top() const;

push：

void push(const value_type& val);

pop：

void pop();

示例一：

#include <iostream>
#include <queue>
using namespace std;
​
int main()
{
    priority_queue<int> pq;
    pq.push(30);
    pq.push(100);
    pq.push(25);
    pq.push(40);
    cout << pq.size() << endl;  // 4
    while (!pq.empty())
    {
        cout << pq.top() << " ";
        pq.pop();
    }
    // 100 40 30 25
    cout << endl;
    return 0;
}

示例二 - 如果 priority_queue 中存储的是自定义类型的数据，用户则需要在自定义类型中提供 < 和 > 的重载：

#include <iostream>
#include <queue>
using namespace std;
​
class Date
{
    friend ostream& operator<<(ostream& out, const Date& d);
public:
    Date(int year = 1949, int month = 10, int day = 1)
        : _year(year), _month(month), _day(day)
    { }
​
    bool operator<(const Date& d) const
    {
        return (_year < d._year)
            || (_year == d._year && _month < d._month)
            || (_year == d._year && _month == d._month && _day < d._day);
    }
​
    bool operator>(const Date& d) const
    {
        return (_year > d._year)
            || (_year == d._year && _month > d._month)
            || (_year == d._year && _month == d._month && _day > d._day);
    }
private:
    int _year;
    int _month;
    int _day;
};
​
ostream& operator<<(ostream& out, const Date& d)
{
    return out << d._year << "-" << d._month << "-" << d._day;
}
​
int main()
{
    priority_queue<Date, vector<Date>, greater<Date>> pq;
    pq.push(Date(2023, 5, 1));
    pq.push(Date(2023, 7, 1));
    pq.push(Date(2023, 6, 1));
    pq.push(Date(2023, 4, 1));
    cout << pq.size() << endl;  // 4
    while (!pq.empty())
    {
        cout << pq.top() << " ";
        pq.pop();
    }
    // 2023-4-1 2023-5-1 2023-6-1 2023-7-1
    cout << endl;
    return 0;
}

 

5.3 - priority_queue 的模拟实现

#pragma once
​
#include <vector>
#include <assert.h>
​
namespace yzz
{
    // 函数对象（仿函数）类
    template<class T>
    struct less
    {
        bool operator()(const T& left, const T& right)
        {
            return left < right;
        }
    };
​
    template<class T>
    struct greater
    {
        bool operator()(const T& left, const T& right)
        {
            return left > right;
        }
    };
​
​
    // priority_queue 容器适配器
    template<class T, class Container = std::vector<T>, class Compare = less<T>>
    class priority_queue
    {
    private:
        void AdjustUp(int child)
        {
            Compare cmp;
            int parent = (child - 1) / 2;
            while (child > 0)
            {
                if (cmp(_ctnr[parent] ,_ctnr[child]))
                {
                    std::swap(_ctnr[parent], _ctnr[child]);
                    child = parent;
                    parent = (child - 1) / 2;
                }
                else
                {
                    break;
                }
            }
        }
​
        void AdjustDown(int parent)
        {
            Compare cmp;
            int sz = _ctnr.size();
            int child = 2 * parent + 1;  // 双亲节点默认和其左孩子进行比较
            while (child < sz)
            {
                if (child + 1 < sz && cmp(_ctnr[child] ,_ctnr[child + 1]))
                {
                    ++child;  // 改为让双亲节点和其右孩子进行比较
                }
​
                if (cmp(_ctnr[parent] ,_ctnr[child]))
                {
                    std::swap(_ctnr[parent], _ctnr[child]);
                    parent = child;
                    child = 2 * parent + 1;
                }
                else
                {
                    break;
                }
            }
        }
​
    public:
        priority_queue() 
        { }
​
        template<class InputIterator>
        priority_queue(InputIterator first, InputIterator last)
        {
            while (first != last)
            {
                push(*first);
                ++first;
            }
        }
​
        bool empty() const
        {
            return _ctnr.empty();
        }
​
        size_t size() const
        {
            return _ctnr.size();
        }
​
        const T& top() const
        {
            return _ctnr.front();
        }
​
        void push(const T& val)
        {
            _ctnr.push_back(val);
            AdjustUp(_ctnr.size() - 1);
        }
​
        void pop()
        {
            assert(!_ctnr.empty()); // 前提是 _ctnr 非空
            std::swap(_ctnr[0], _ctnr[_ctnr.size() - 1]);
            _ctnr.pop_back();
            AdjustDown(0);
        }
    private:
        Container _ctnr;
    };
}

 

melonyzzZ
关注
专栏目录
C++-容器适配器- stack、queue、priority_queue和仿函数
GGbond665的博客
10-03 1277
C++-容器适配器- stack、queue、priority_queue和仿函数
标准模板库STL——容器适配器-stack/queue/priority_queue
qq_66095714的博客
08-15 277
容器适配器的理解、容器适配器的实现与使用、三类容器适配器
容器适配器stack,queue和priority_queue
weixin_57023347的博客
07-23 1986
一.什么是容器适配器 容器适配器是一个封装了序列容器的一个类模板，它在一般的序列容器的基础上提供了一些不同的功能。之所以称为容器适配器，是因为它是适配容器来提供其它不一样的功能。通过对应的容器和成员函数来实现我们需要的功能。 下面介绍了三个容器适配器：statk<T>,queue<T>,priority_queue<T>。 注意：容器适配器都不存在迭代器。 二.stack栈 2.1 stack的介绍 stac...
C++初阶-stack/queue/priority_queue的使用和模拟
~
01-10 897
【C++初阶学习】stack/queue/priority_queue的使用和模拟零、前言一、stack的介绍和使用1、stack的介绍2、stack的使用二、queue的介绍和使用1、queue的介绍2、queue的使用三、priority_queue的介绍和使用1、priority_queue的介绍2、priority_queue的使用四、容器适配器五、deque的简单介绍六、stack的模拟实现七、queue的模拟实现八、priority_queue的模拟实现 零、前言 本章主要讲解学习C++中的.
c++--stack，queue，priority_queue
includeevey的博客
01-13 2106
栈，队列，优先级队列，deque，仿函数
容器适配器---deque和STL ---stack queue priority_queue的模拟实现 C++
qzt__l0ve的博客
05-02 757
适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和queue只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque。
C++---stack,queue,priority_queue 模拟实现
blue_jun_的博客
10-07 721
deque容器简介，栈和队列及优先级队列实现，仿函数使用
[C/C++]详解STL容器4--stack、queue和priority_queue的功能和模拟实现，deque和容器适配器的介绍
RMA515T的博客
09-25 2635
本文介绍了stack、queue和priority_queue的常用接口的使用，并对其进行了模拟实现，还对deque和容器适配器进行了介绍。 一、stack的功能和模拟实现 1.stack的介绍 stack<T>容器适配器中的数据是以 LIFO 的方式组织的,是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定 的成员函数来访问其元素，将特定类作为其底
C++STL---priority_queue知识总结及模拟实现
weixin_73919606的博客
07-17 948
和stack与queue一样，priority_queue也是一种容器适配器。他的本质其实是堆，作优先级队列的底层需要能够通过随机迭代器访问，所以他的底层是可以由vector和queue实例化，默认情况下priority_queue默认是用vector作为底层实例化，此外我们还可以特指定deque作为他的底层进行实例化。需要支持随即迭代器，是因为要始终维持堆，优先级队列的本质就是堆。容器适配器通过在需要时自动调用算法函数make_heap，push_heap，pop_heap来始终维持堆。
C++进阶：STL容器适配器详解 - stack, queue与priority_queue
容器适配器是C++标准模板库(STL)的一部分，它们提供了一些基础的数据结构实现，如stack（栈）、queue（队列）和priority_queue（优先队列），这些适配器帮助开发者在不支持迭代器的情况下使用这些数据结构。...
【C++】容器适配器-----stack、queue、priority_queue
Vcrossover的博客
03-03 280
容器适配器概念分类接口底层结构stack模拟实现queue模拟实现priority_queue模拟实现 概念   我们可以简单的将容器适配器当做一个接口装置。有的电脑上没有数据转接口，但是有usb接口，这是我们没必要重新买一个电脑，我们可以做一个usb数据转接线。而这根数据转接线就类似于适配器一样。   在C++中，我们已经有了（vector、list、deque等容器）插入、删除、迭代器就电脑usb接口，当我们想要实现栈的操作时，我么没有必要再重新写新的数据结构，只需要将其接口进行重新的封装，相当于做了一
C++ STL容器适配器详解：stack, queue与priority_queue
标题："容器适配器简介 - C++ STL标准模板库讲解PPT" 描述了C++标准模板库（STL）中的几个重要容器适配器，包括stack（栈）、queue（队列）和priority_queue（优先级队列），它们分别基于先进后出（LIFO）、先进先出...
【C++ STL】容器适配器 Container adapter（stack & queue & priority_queue）
codewinter的博客
05-27 1070
文章目录一、STL - stack1.1 stack 的介绍1.2 stack 的使用1.3 stack 的模拟实现二、STL - queue 的介绍2.1 queue 的介绍2.2 queue 的使用2.3 queue 的模拟实现三、STL - priority_queue3.1 priority_queue 的介绍3.2 priority_queue 的使用3.3 仿函数（⭐重要）① 什么是仿函数② 模板实例化时，仿函数的使用3.4 priority_queue 的模拟实现四、容器适配器4.1 什么是容
C++ queue和priority_queue
weixin_45743799的博客
03-17 492
queue 和 priority_queue 都是容器适配器，要使用它们，必须包含头文件 。 queue queue 就是“队列”。队列是先进先出的，和排队类似。队头的访问和删除操作只能在队头进行，添加操作只能在队尾进行。不能访问队列中间的元素。 queue 可以用 list 和 deque 实现，默认情况下用 deque 实现。 queue 的定义如下： template < class ...
《C++显式类型转换：解析多种转换方式的奥秘》
xy520521的博客
10-27 681
当我们从一个存储 Shape 指针的容器中取出指针并希望将其转换为具体的派生类指针以调用特定的绘制方法时，动态_cast可以确保转换的安全性，避免在对象类型不匹配时出现错误。需要注意的是，使用 const_cast修改一个原本被定义为 const 的对象可能会导致未定义的行为，因为这违反了 const 的语义。例如，当我们有一个 const 引用指向一个对象，但在某个特定的函数内部，我们知道这个函数不会修改对象的值，但需要将其传递给一个非 const 版本的函数时，可以使用 const_cast。
linux C++ 动态库dlopen加载示例
编程之道在明明德在亲民在止于至善
10-25 713
linux C++ 动态库dlopen加载示例
linux c-exec系列函数学习
程序猿的成长笔记
10-25 287
这些函数都是以替换的方式，创建一个新的进程替代当前的进程。新的进程与原来的进程号相同，所有的用户空间(代码段、数据段)及部分的内核空间都可以视为是全新的。要注意与fork函数的区别。：可以参考va_start系列的(宏)函数，因此，无论是...，还是vector，还是环境变量的数组，最后一个元素必须是。，相关的错误代码会被设置到errno中。在执行错误的有返回值，且返回值为。
8 深入理解C语言中的变量概念
qq_57484399的博客
10-25 445
在我们日常生活或数学学习中，变量是一个常见的概念。比如在函数中，我们有自变量和因变量。在编程中，变量的作用类似，但它更加具体和实际。变量是程序中可以改变的量，我们可以用一个符号或字母来表示它，比如xy或z。通过今天的学习，我们了解了变量在C语言中的重要性和基本概念。变量是程序中存储和操作数据的关键，它们使得程序能够处理变化的数据。理解变量的本质和如何使用它们，是学习C语言的基础。希望这个解释能够帮助你更好地理解变量，并在你的编程旅程中发挥作用。如果你有任何疑问或需要进一步的解释，请随时提问。
c加加11第一弹~
最新发布
2301_81230745的博客
10-30 710
在C++98中的普通引用与const引用在引用实体上的区别int main()// 普通类型引用只能引用左值，不能引用右值int a = 10;// ra为a的别名// 编译失败，因为10是右值return 0;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值