stack、queue、priority_queue的使用和简单实现【STL】

最新推荐文章于 2023-09-25 07:49:52 发布
最新推荐文章于 2023-09-25 07:49:52 发布
阅读量648 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63312733/article/details/127196814
版权

文章目录

stack

关于栈和队列，我们在之前数据结构部分就已经学习了，并且用C实现了它们，在这里只是用C++做一样的工作。目的是复习和理解C++的优越性。所以在这里只对模拟实现着重介绍。对于STL中的栈和队列，用C++实现是比较简单的，因为我们只需要保证我们实现出来的数据结构符合栈和队列的特点即可，至于用什么容器存放数据，STL库中有vector和list，任君选择。

下面以vector为例。

如果有需要的话，强烈建议阅读栈和队列，这里结合图示详细介绍了栈和队列的特性，只需要阅读介绍部分即可。

stack的使用

#include <stack>
void test1()
{
    stack<int> st;
    //入栈
    st.push(1);
    st.push(2);
    st.push(3);
    st.push(4);
    st.push(5);
    cout << "size:" << st.size() << endl;
    //先打印后出栈
    while(!st.empty())
    {
        cout << st.top() << " ";
        st.pop();
    }
    cout << endl;
}
//也可以指定适配器为vector或list
//需要包含相应头文件
void test2()
{
    stack<int, vector<int>> st;
    st.push(1);
    st.push(2);
    st.push(3);
    st.push(4);
    st.push(5);
    st.push(6);

    cout << "size:" << st.size() << endl;
    while(!st.empty())
    {
        cout << st.top() << " ";
        st.pop();
    }
    cout << endl;
}
void STL_stack_test()
{
    test1();
    test2();
}
int main() {
    STL_stack_test();
    return 0;
}

【输出】

size:5
5 4 3 2 1
size:6
6 5 4 3 2 1

stack的实现

通过查阅文档：

image-20221006222832296

STL的每个容器底层都有我们要学习的新东西，这里第二个模板参数Container就是我们要在栈和队列中学习的。

容器适配器

适配器的含义

「适配器」是一个泛称，例如我们生活中有适用各种设备的电源适配器。那么我们STL中也有容器适配器。

  • 对于上层，STL面对的是程序员，电源适配器面对的是用户，把插头插入插孔，每个插孔的电压都是220V交流电；
  • 对于底层，STL面对的是底层实现，电源适配器面对的是各种不同的设备，这些设备需要的电压大小、交流电还是直流电都是不同的。

结合文档中模板的声明来看，stack里的适配器Container其实没什么高大上的，其实就是因为stack本身可以用list或vector等数据结构实现，所以增加了一个参数让使用者自己选择底层是用哪个容器保存stack元素的数据。这里给了Container以缺省值deque<T>，表明stack底层默认以deque为容器。

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

  • deque是STL中的双端队列，是一种具有队列和栈性质的抽象数据类型。双端队列中的元素可以从两端弹出，插入和删除操作限定在队列的两边进行。它定义在<queue>头文件中。

不管是使用STL中的vector还是list，或者是默认的deque，stack的模拟实现都非常简单，因为STL各个容器的接口十分类似。而且它们对外都是封装好了的，所以我们实现stack只需要保证使用它们的接口，达到“先进先出”的效果即可。

用双端队列（数组）来看，stack只能从后入栈，从头弹出，那么也就对应这deque中的尾插和头删接口。

【代码】

#pragma once
#include <iostream>
using namespace std;
namespace xy
{
    //定义适配器Container
    template<class T, class Container = deque<T>>//这里的deque可以设置自己想要的结构,比如vector或list
            class stack{
            public:
                void push(const T& x)
                {
                    _con.push_back(x);
                }
                void pop()
                {
                    _con.pop_back();
                }
                T& top()
                {
                    return _con.back();
                }
                const T& top() const
                {
                    return _con.back();
                }
                bool empty()
                {
                    return _con.size() == 0;
                }
                const size_t size() const
                {
                    return _con.size();
                }
                void swap(stack<T, Container>& st)
                {
                    std::swap(st._con);
                }
            private:
                Container _con;//定义成员变量
            };
    /// __TEST__ 
    void test1()
    {
        stack<int> st;
        st.push(1);
        st.push(2);
        st.push(3);
        st.push(4);
        st.push(5);
        cout << "size:" << st.size() << endl;
        while(!st.empty())
        {
            cout << st.top() << " ";
            st.pop();
        }
        cout << endl;
    }
}

可以通过命名空间xy内的函数测试一下：
【输出】

size:5
5 4 3 2 1

queue

queue的使用

同样，queue在数据结构部分已经学习，在这里简要介绍STL中的各个接口的使用。

void STL_queue_test()
{
    queue<int, list<int>> q;
    q.push(1);
    q.push(2);
    q.push(3);
    q.push(4);
    cout << "size:" << q.size() << endl; //4
    while (!q.empty())
    {
        cout << q.front() << " ";
        q.pop();
    }
    cout << endl;
}

【输出】

size:4
1 2 3 4

底层实现也是和stack的实现类似，都是使用已经封装好的接口达到“先进先出”的效果即可。

#pragma once
#include <iostream>
#include <queue>
using namespace std;

namespace xy
{
    //定义适配器Container
    template<class T, class Container = std::deque<T>>//这里的deque可以设置自己想要的结构,比如vector或list
    class queue{
    public:
        void push(const T& x)
        {
            _con.push_back(x);
        }
        void pop()
        {
            _con.pop_front();
        }
        T& front()
        {
            return _con.front();
        }
        const T& front() const
        {
            return _con.front();
        }
        T& back()
        {
            return _con.back();
        }
        const T& back() const
        {
            return _con.back();
        }
        bool empty()
        {
            return _con.size() == 0;
        }
        const size_t size() const
        {
            return _con.size();
        }
        void swap(queue<T, Container>& st)
        {
            std::swap(st._con);
        }
    private:
        Container _con;//定义成员变量
    };
    /// __TEST__ 
    void test1()
    {
        queue<int> st;
        st.push(1);
        st.push(2);
        st.push(3);
        st.push(4);
        st.push(5);
        cout << "size:" << st.size() << endl;
        while(!st.empty())
        {
            cout << st.front() << " ";
            st.pop();
        }
        cout << endl;
    }
}

测试一下：
【输出】

size:5
1 2 3 4 5

priority_queue

priority_queue的使用

priority_queue，优先级队列，通过查阅文档可以知道，它其实就是一个存放大小堆的容器，由于数组比链表更有优势，所以它默认是以vector为容器。

严格来说，priority_queue是容器适配器，因为它底层可以指定不同类型的容器存放数据，不过对于我们的「使用」而言，它就是个容器，我们依然用push、pop等操作，只是在「实现」时我们多了一个指定底层容器的步骤。

image-20221007103641175

image-20221007104341649

从文档的描述来看，优先级队列默认是大堆。由于之前已经学习过二叉树的大小堆算法，所以在这里模拟实现优先级队列一是把之前知识[复习一遍](3. 二叉树的顺序存储)（主要是向上调整和向下调整算法），二是学习优先级队列中新的东西：「仿函数」。

仿函数（functor）

从第二个模板参数可以看到，优先级队列多了一个Compare的参数，它的内容是还与适配器有关。

其实没那么高大上，就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了。

举个例子：

下面单独封装了一个类Add，类中重载了operator()，在这个重载函数中，实现了加法功能

#include <iostream>
using namespace std;

class Add
{
public:
    int operator()(int& x, int& y)
    {
        return x + y;
    }
};

int main()
{
    int a  = 1, b = 2;
    Add add;
    cout << add(a, b) << endl;
    return 0;
}

【输出】

3

如果但看main函数中的打印函数部分，不管是形式还是传参，都和函数无异，但是它的底层就是一个被重载的operator()。

仿函数就是让operator()有了函数的特性，在C中我们用函数指针和回调函数实现仿函数。

那么仿函数在这里有什么作用呢？

在向上调整和向下调整算法中，需要比较孩子和父亲结点的值的大小，然后交换，调整，这样才能得到大堆或小堆（堆顶结点的值一定是极值）。

那么既然要比较，就直接让父亲结点和孩子节点在调整函数内部比较不就好了，为什么还要另外写两个类（less和greater）来封装这两个具有比较功能的重载函数呢？

要知道，模板参数中的Compare是有缺省值的，它默认是less，也就是说它可以改变比较方式，就像一个开关一样。用户切换大小堆只要传入一个参数即可，而不是翻到源代码，将里面的<改成>。

【代码】

#pragma once
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
namespace xy
{

    //定义比较方式以确定结构为大堆或小堆
    template<class T>
        class less
        {
            bool operator()(const T& x, const T& y)
            {
                return  x < y;
            }
        };
    template<class T>
        class greater
        {
            bool operator()(const T& x, const T& y)
            {
                return  x > y;
            }
        };
    //定义优先级队列
    template<class T, class Container = vector<T>, class Compare = less<T>>
        class priority_queue
        {
            public:
            void push(const T& x)
            {
                _con.push_back(x);
                adjust_up(_con.size() - 1);
                //因为是用vector,所以头插也可以,但是这样就要向下调整,时间复杂度更高
            }
            //弹出优先级队列(大小堆)的堆顶元素
            void pop()
            {
                //将堆顶元素和堆尾元素互换
                swap(_con[0], _con[_con.size() - 1]);
                //弹出
                _con.pop_back();
                //从现有堆的第一个元素向下调整(此时没有"堆顶"可言)
                adjust_down(_con.size(), 0);
            }
            T& top()
            {
                return _con[0];
            }
            const T& top() const
            {
                return _con[0];
            }
            const size_t size() const
            {
                return _con.size();
            }
            bool empty()
            {
                return _con.empty();
            }
            //向上调整
            void adjust_up(int child)
            {
                int parent = (child - 1) / 2;
                while(child > 0)//即使child=0,parent也是0,所以还要比较一次
                {
                    if(_cmp(_con(parent), _con(child)))
                    {
                        //父子结点交换
                        swap(_con(parent), _con(child));
                        //更新父子结点,比较范围向上移动
                        //先修改下面的,即child
                        child = parent;
                        parent = (child - 1) / 2;
                    }
                    else
                        break;
                }
            }
            //向下调整
            void adjust_down(int n, int parent)
            {
                int child = 2 * parent + 1;
                while (child < n)
                {
                    if (child + 1 < n&&_comp(_con[child], _con[child + 1]))
                    {
                        child++;
                    }
                    if (_cmp(_con[parent], _con[child]))
                    {
                        //父子结点交换
                        swap(_con[child], _con[parent]);
                        //继续向下
                        parent = child;
                        child = 2 * parent + 1;
                    }
                    else
                        break;
                }
            }
            private:
            Container _con;//定义底层实现的容器
            Compare _cmp;//定义比较方式
        };
}

模拟实现优先级队列的核心部分是实现向上调整和向下调整算法的代码，这也是面试中常见的问题。

【测试】

void my_priority_queue_test()
{
    xy:priority_queue<int> pq;
    pq.push(1);
    pq.push(5);
    pq.push(9);
    pq.push(7);
    pq.push(10);
    pq.push(3);
    pq.push(0);
    while (!pq.empty())
    {
        cout << pq.top() << " ";
        pq.pop();
    }
    cout << endl;
}

【输出】

10 9 7 5 3 1 0

Man9Oo
关注
专栏目录
C++ STL源码剖析之容器配接器stack与queue、priority_queue
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-26 345
C++ STL源码剖析之容器配接器stack与queue、priority_queue导语stackqueuepriority_queue 导语 为何stack与queue不被称为容器呢？ 下面本节带着这个问题来深入源码分析。 stack 在stack的源码中我们关注两点： 默认_Sequence为deque 内部函数实现是调用_Sequence对应容器的函数。 template<typename _Tp, typename _Sequence = deque<_Tp> > clas
C++ STL (5) queue队列和priority_queue优先队列的简单用法
瞎扯淡小基地
04-26 328
C++ STL (5) queue队列和priority_queue优先队列的简单用法 队列的简单介绍 queue队列的简单介绍 队列(Queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表（先进先出）。允许插入的端是队尾，允许删除的端是队头。 queue 模板类需要两个模板参数，一个是元素类型，一个容器类型，元素类型是必要的，容器类型是可选的，默认为deque 类型。 队列的...
STL中的queue，stack和priority_queue的基本操作
亲亲Friends的博客
05-12 385
STL = Standard Template Library，标准模板库，惠普实验室开发的一系列软件的统称。 它是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室工作时所开发出来的。这可能是一个历史上最令人兴奋的工具的最无聊的术语。STL实际上是一个非常有用的工具，它使你避免了许多重复的编码工作，大大提高了编码效率。比如，当你需要使用一个队列时，...
STL中的stack和queue和priority_queue的使用和模拟实现
weixin_45897952的博客
04-28 958
目录 1.STL中stack的基本操作： 2.STL中queue的基本操作 3.stack的模拟实现： 4.queue的模拟实现： 5.priority_queue:(优先级队列同样也是容器适配器------>就是包装其他结构) 5.1priority_queue的使用： 5.2priority_queuede模拟实现： 6.STL库中创建堆的函数及其使用： 1.什么是仿函数 关于栈和队列几个问题： 1.为什么栈没有提供迭代器呢？ 2.逆波兰表达式———————后缀表达式
STL容器及其简单应用(stack、priority_queue、vector、deuqe、list、map/multimap、set/multiset)
hanhan的博客
08-22 444
目录前言【1】stack操作以及应用二、使用步骤1.引入库2.读入数据总结 前言 【1】stack操作以及应用 #include <iostream> #include <cstdio> #include <fstream> #include <algorithm> #include <cmath> #include <deque> #include <vector> #include <queue&.
C++ STL中的容器适配器 stack、queue、priority_queue
Butayarou的博客
04-07 3886
C++ STL中的容器适配器 stack、queue、priority_queue 和 deque 简介。
STL详解---stack与queue(含priority_queue)的使用
分享学习的知识，记录我的技术成长道路
04-06 678
stack与queue不同于之前的string，vector，list，它们是一种容器适配器，而不是一种容器。并且是不支持迭代器的。
C++ STL中stack、queue和priority_queue的使用
STL（Standard Template Library，标准模板库）为开发者提供了便捷的方式来实现和使用这些数据结构。 1. stack（栈） 栈是一种后进先出（Last In, First Out, LIFO）的数据结构。在C++中，`stack`模板类位于`<stack...
容器适配器中stack queue priority_queue的介绍及模拟实现
JuLiJuLi.的博客
01-11 701
适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成他人希望的另外一个接口。
【C++】STL详解（八）—— priority_queue的使用及模拟实现&&仿函数
最新发布
Sherry的博客
09-25 170
今天我们比较详细地完成了priority_queue的使用及模拟实现，了解了一些有关的底层原理。接下来，我们将进行C++模板进阶操作的的学习。希望我的文章和讲解能对大家的学习提供一些帮助。
STL 容器操作总结（vector、set、unordered_map、stack、queue、string）
ZauberC的博客
05-20 299
vector、unordered_map、unordered_set、string、stack、queue使用方法以及函数总结快速浏览版。
浅整理一下STL(顺序式容器)vector、stack、queue、priority_queue、list
WSY444的博客
03-01 734
顺序式容器： 关于vector的简单用法： 头文件：<vector> 1.vector动态数组，从末尾能快速插入与删除，直接访问任何元素。 2.vector能用来存放任何类型的对象： Int：vector<int>a;//默认初始值,a为空 vector<int>b(a);//用a定义b vector<int>a(100);//有100个值为0的元素 vector<int>a(100,6)......
【STL】stack、queue、priority_queue模拟实现
m0_51064412的博客
09-21 216
文章目录一. 一.
【C++】stack、queue、priority_queue
knous
07-15 193
stack、queue、priority_queue的讲解及模拟实现
c++--stack，queue，priority_queue
includeevey的博客
01-13 2110
栈，队列，优先级队列，deque，仿函数
stack、queue和priority_queue
qq_65285898的博客
02-12 1381
适配器模式的首秀
C++STL详解（七）：stack、queue与priority_queue的使用及其模拟实现
weixin_51885188的博客
02-19 883
文章目录stackstack的介绍栈的使用queuequeue的介绍队列的使用priority_queuepriority_queue的介绍优先队列的使用容器适配器什么是容器适配器STL标准库中stack、queue和priority_queue的底层结构deque的简单介绍（了解）stack的模拟实现queue的模拟实现仿函数priority_queue的模拟实现向上调整算法向下调整算法代码实现 stack stack的介绍 stack这种容器就像是手枪装填子弹然后开枪一样，先装进去的子弹会在下面然后
【C++】stack、queue和priority_queue的使用及模拟实现（包括deque、仿函数、反向迭代器）
lgr669877aqa的博客
06-29 287
我们通过学习数据结构时知道栈和队列是特殊的线性表，可以通过顺序表或链表来实现，在C++中把这种模式称为适配器模式，用已有的东西封装成你想要的东西。容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。stack的默认底层容器是deque。队列也是一种容器适配器，由于出队列要进行头删，所以队列的底层容器一般是list或者deque，默认是deque。
C++复习（三）：STL库之deque、stack、queue、priority_queue容器
cly141220010的博客
02-07 574
本文主要参考https://blog.csdn.net/weixin_34128839/article/details/91686932 queue，stack是基于deque实现的，都是顺序容器，支持随机访问。priority_queue是基于vector实现的，底层数据结构是堆。 list的本质是一个双向链表，内存空间不连续，通过指针进行操作。 deque是一个double-ended......
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值