stack和queue的基本知识

最新推荐文章于 2024-09-27 17:57:19 发布
最新推荐文章于 2024-09-27 17:57:19 发布
阅读量931 收藏 12
点赞数 14
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wangtffn/article/details/140702251
版权

（写给未来遗忘的自己）

stack 

 在 C++ 中，stack 是标准模板库（STL）的一部分，是一种容器适配器。容器适配器为现有的容器提供了一种特定的接口，而不改变底层容器的实现方式。stack 是一个典型的后进先出（LIFO，Last In First Out）数据结构。

基本特性

  • 容器适配器：stack 是一个容器适配器，默认情况下使用 deque 作为底层容器，但可以使用任何符合要求的容器，如 vector 或 list。
  • 接口：stack 提供了一组有限的接口，以限制对底层容器的访问方式。这些接口包括 push、pop、top、empty 和 size。

stack 的常用方法

  1. push(const T& value)：向栈顶添加一个元素。
  2. pop()：移除栈顶的元素。
  3. top()：返回栈顶的元素。
  4. empty()：检查栈是否为空。
  5. size()：返回栈中元素的数量。
#include <iostream>
#include <stack>
#include <vector>
#include <list>

int main() {
    std::stack<int> s; // 使用默认的 deque 作为底层容器
    std::stack<int, std::vector<int>> s2; // 使用 vector 作为底层容器
    std::stack<int, std::list<int>> s3; // 使用 list 作为底层容器

    s.push(1);
    s.push(2);
    s.push(3);

    while (!s.empty()) {
        std::cout << s.top() << " "; // 输出栈顶元素
        s.pop(); // 移除栈顶元素
    }

/**************************************************************************************/
     // top：返回栈顶元素
    std::cout << "Top element: " << s.top() << std::endl;  // 输出 3

    // pop：移除栈顶元素
    s.pop();
    std::cout << "Top element after pop: " << s.top() << std::endl;  // 输出 2

    // size：返回栈中元素的数量
    std::cout << "Stack size: " << s.size() << std::endl;  // 输出 2

    // empty：检查栈是否为空
    std::cout << "Is stack empty? " << (s.empty() ? "Yes" : "No") << std::endl;  // 输出 No

    // 继续 pop 直到栈为空
    s.pop();
    s.pop();
    std::cout << "Is stack empty after popping all elements? " << (s.empty() ? "Yes" : "No") << std::endl;  // 输出 Yes

    return 0;
}

 

stack 的实现

stack 是通过对底层容器的接口进行包装和限制来实现的。以下是一个简化的实现示例：

#include <deque>

template <typename T, typename Container = std::deque<T>>
class Stack {
public:
    void push(const T& value) {
        container.push_back(value);
    }

    void pop() {
        container.pop_back();
    }

    T& top() {
        return container.back();
    }

    const T& top() const {
        return container.back();
    }

    bool empty() const {
        return container.empty();
    }

    size_t size() const {
        return container.size();
    }

private:
    Container container;
};

附：自定义模板的解释

template <typename T, typename Container = std::deque<T>>

/*
1.template <typename T, typename Container = std::deque<T>>:

template <typename T, typename Container = std::deque<T>> 
声明了一个模板，其中 T 是类型参数，Container 是一个模板参数，
其默认类型是 std::deque<T>。这意味着在没有指定 Container 类型时，
默认使用 std::deque<T> 作为 Container 类型。


2.typename T:

T 是一个模板类型参数，表示可以传递任何类型。


3.typename Container = std::deque<T>:

Container 是另一个模板类型参数，它有一个默认值 std::deque<T>。
std::deque<T> 是一个标准库的双端队列（deque），它是 Container 的默认类型。
这样一来，如果用户在实例化模板时不指定 Container 类型，模板将使用 
std::deque<T> 作为默认的容器类型。


*/

stack 不提供迭代器

stack 不提供迭代器，因为它的设计是为了隐藏底层容器的细节，并且只提供与栈操作相关的方法。迭代器允许对容器的任意访问，这与栈的 LIFO 特性不符。

如果需要遍历 stack 中的元素，应该使用底层容器。（一般不建议使用）

#include <stack>
#include <vector>
#include <iostream>

int main() {
    std::stack<int, std::vector<int>> s;
    s.push(1);
    s.push(2);
    s.push(3);

    std::vector<int>& underlyingContainer = const_cast<std::vector<int>&>(s._Get_container());

    for (auto it = underlyingContainer.begin(); it != underlyingContainer.end(); ++it) {
        std::cout << *it << " ";
    }

    return 0;
}

queue

std::queue 也是 C++ 标准模板库（STL）中的一个容器适配器，用于实现先进先出（FIFO，First In First Out）数据结构。与 std::stack 类似，std::queue 也依赖于底层容器来存储元素，但它对外只暴露队列操作的接口。

queue常用方法

  • push(const T& value)：向队列尾部添加元素。
  • pop()：移除队列头部的元素。
  • front()：返回队列头部的元素。
  • back()：返回队列尾部的元素。
  • empty()：检查队列是否为空。
  • size()：返回队列中元素的数量。

 

#include <iostream>
#include <queue>
#include <deque>
#include <list>

int main() {
    // 使用默认的 std::deque 作为底层容器
    std::queue<int> q;

    // push：向队列尾部添加元素
    q.push(1);
    q.push(2);
    q.push(3);

    // front：返回队列头部的元素
    std::cout << "Front element: " << q.front() << std::endl;  // 输出 1

    // back：返回队列尾部的元素
    std::cout << "Back element: " << q.back() << std::endl;  // 输出 3

    // pop：移除队列头部的元素
    q.pop();
    std::cout << "Front element after pop: " << q.front() << std::endl;  // 输出 2

    // size：返回队列中元素的数量
    std::cout << "Queue size: " << q.size() << std::endl;  // 输出 2

    // empty：检查队列是否为空
    std::cout << "Is queue empty? " << (q.empty() ? "Yes" : "No") << std::endl;  // 输出 No

    return 0;
}

自定义底层容器

你可以使用 std::list 或 std::vector 作为 queue 的底层容器，只要它们支持必要的操作

#include <iostream>
#include <queue>
#include <list>

int main() {
    std::queue<int, std::list<int>> q;

    q.push(1);
    q.push(2);
    q.push(3);

    std::cout << "Front element: " << q.front() << std::endl;  // 输出 1
    std::cout << "Back element: " << q.back() << std::endl;  // 输出 3

    q.pop();
    std::cout << "Front element after pop: " << q.front() << std::endl;  // 输出 2
    std::cout << "Queue size: " << q.size() << std::endl;  // 输出 2
    std::cout << "Is queue empty? " << (q.empty() ? "Yes" : "No") << std::endl;  // 输出 No

    return 0;
}

queue 的实现

#include <iostream>
#include <queue>
#include <deque>
#include <list>

// 自定义 queue 类，公开底层容器的访问
template <typename T, typename Container = std::deque<T>>
class MyQueue {
public:
    using value_type = T;
    using container_type = Container;
    using size_type = typename Container::size_type;

    explicit MyQueue(const Container& cont = Container()) : c(cont) {}
    explicit MyQueue(Container&& cont = Container()) : c(std::move(cont)) {}
    MyQueue(const MyQueue& other) : c(other.c) {}
    MyQueue(MyQueue&& other) noexcept : c(std::move(other.c)) {}

    MyQueue& operator=(const MyQueue& other) {
        c = other.c;
        return *this;
    }

    MyQueue& operator=(MyQueue&& other) noexcept {
        c = std::move(other.c);
        return *this;
    }

    bool empty() const { return c.empty(); }
    size_type size() const { return c.size(); }
    value_type& front() { return c.front(); }
    const value_type& front() const { return c.front(); }
    value_type& back() { return c.back(); }
    const value_type& back() const { return c.back(); }
    void push(const value_type& value) { c.push_back(value); }
    void push(value_type&& value) { c.push_back(std::move(value)); }
    void pop() { c.pop_front(); }

    // 公开底层容器的访问
    Container& get_container() { return c; }
    const Container& get_container() const { return c; }

private:
    Container c;
};

int main() {
    // 使用自定义的 queue 类，底层容器为 std::deque
    MyQueue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);

    // 获取底层容器的引用
    std::deque<int>& underlyingContainer = q.get_container();

    // 遍历底层容器
    for (const int& elem : underlyingContainer) {
        std::cout << elem << " ";
    }

    return 0;
}

 不同底层实现的区别

std::queue 和 std::stack 是容器适配器，它们可以使用不同的底层容器实现来存储元素。选择不同的底层容器会影响到这些适配器的性能和特性。主要的底层容器包括 std::deque、std::vector 和 std::list。

1. std::deque

std::deque（双端队列）是 std::queue 和 std::stack 的默认底层容器，因为它提供了在头部和尾部的高效插入和删除操作。

  • 优点：

    • 支持在头部和尾部进行常数时间的插入和删除操作。
    • 动态调整大小，不需要额外的内存拷贝。
    • 支持随机访问元素。

  • 缺点：

    • 内部实现比较复杂，可能会占用更多的内存。
    • 相比 std::vector 在元素访问和遍历上稍慢。
#include <iostream>
#include <queue>
#include <deque>

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

    q.push(1);
    q.push(2);
    q.push(3);

    std::cout << "Front element: " << q.front() << std::endl;  // 输出 1
    std::cout << "Back element: " << q.back() << std::endl;  // 输出 3

    q.pop();
    std::cout << "Front element after pop: " << q.front() << std::endl;  // 输出 2

    return 0;
}

 

2. std::vector

std::vector 是动态数组，支持快速的随机访问。

  • 优点：

    • 提供常数时间的随机访问。
    • 适合在尾部进行插入和删除操作。
    • 内存布局连续，有利于缓存局部性。

  • 缺点：

    • 在头部插入和删除元素时效率较低，因为需要移动所有元素。
    • 当重新分配内存时，可能需要将整个数组复制到新位置。
#include <iostream>
#include <stack>
#include <vector>

int main() {
    std::stack<int, std::vector<int>> s;

    s.push(1);
    s.push(2);
    s.push(3);

    std::cout << "Top element: " << s.top() << std::endl;  // 输出 3

    s.pop();
    std::cout << "Top element after pop: " << s.top() << std::endl;  // 输出 2

    return 0;
}

3. std::list

std::list 是一个双向链表。

  • 优点：

    • 支持在任何位置进行常数时间的插入和删除操作。
    • 不需要移动其他元素。

  • 缺点：

    • 不支持随机访问，需要线性时间进行元素访问。
    • 内存开销较大，因为每个元素都需要存储指向前后元素的指针。
    • 相比 std::vector 和 std::deque，遍历速度较慢。
#include <iostream>
#include <queue>
#include <list>

int main() {
    std::queue<int, std::list<int>> q;

    q.push(1);
    q.push(2);
    q.push(3);

    std::cout << "Front element: " << q.front() << std::endl;  // 输出 1
    std::cout << "Back element: " << q.back() << std::endl;  // 输出 3

    q.pop();
    std::cout << "Front element after pop: " << q.front() << std::endl;  // 输出 2

    return 0;
}

 

Wangtffn
关注
stack和queue基础知识
qq_51128507的博客
04-06 89
在学习算法的过程中，对代码随想录里面的四个问题印象很深刻，从而想着记录一下，当作笔记可以出一道面试题：栈里面的元素在内存中是连续分布的么？陷阱1：栈是容器适配器，底层容器使用不同的容器，导致栈内数据在内存中是不是连续分布。陷阱2：缺省情况下，默认底层容器是deque，那么deque的在内存中的数据分布是什么样的呢？答案是：不连续的，deque是可以两边扩展的，而且deque里元素并不是严格的连续分布的。1.那么这个维护元素单调递减的队列就叫做单调队列，即单调递减或单调递增的队列。
【C++】stack和queue
柯礼的博客
01-04 1059
栈和队列
Java数据结构-Stack和Queue
qq_45965652的博客
12-08 112
Java中的栈和队列知识总结。
C++之stack 和 queue
2302_79376097的博客
09-25 1266
在数据结构部分我们通过C实现了栈和队列，本节我们将了解C++版本下的stack和queue。我们将会很轻松的学习这部分知识。后进先出1. 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元 素，另一端提取元素。2. 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供 一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 24万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
[C++基础]-stack和queue
分享技术
09-15 964
了解栈和队列的基本知识，简单的模拟实现栈和队列，认识双端队列和priority_queue的使用，知道什么是仿函数，模拟实现反向迭代器。
C++语法知识点合集：10.stack和queue
2302_79453595的博客
09-06 847
C++ 中的 stack 是一种数据结构，位于标准模板库（STL）中。它遵循后进先出（LIFO, Last In First Out）的原则，也就是说，最后插入的元素最先被移除。LIFO 结构：最后插入的元素最先被取出。限制访问方式：只能访问栈顶元素，无法直接访问其他元素。队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
C++笔记---stack和queue
2302_80372340的博客
09-11 764
queue---队列，是一种“先进先出，后进后出”的数据结构。此处的queue是STL库中定义的一个类模板，用于实例化出存储各种类型数据的队列。判断队列是否为空(空true/非空false)返回队列中的数据个数T& front();返回队头元素(目前最早进最先出的元素)T& back();返回队尾元素(目前最后进最后出的元素)入队列(到队尾)void pop();出队列(删除队头元素)交换两个队列的内容。
stack和queue的模拟实现
2301_79969994的博客
06-04 1622
通过对 C++ 中 stack 和 queue 的模拟实现，我们深入了解了容器适配器的工作原理和优势。这些适配器通过封装底层容器，提供了简洁而统一的接口，使得数据结构的操作变得更加直观和便捷。我们的模拟实现展示了如何利用已有的容器类来构建自定义的数据结构，同时也强调了代码复用和隐藏实现细节的重要性。在实际开发中，选择合适的数据结构和容器适配器能够显著提升代码的可读性、可维护性和性能。因此，熟练掌握和灵活运用这些基础工具，是每一个 C++ 开发者必备的技能。
stack_queue_p2pchat_practice:只是使用Stack和Queue技术的Java实践聊天应用程序
03-14
Stack和Queue是两种基本的线性数据结构，它们在程序设计中扮演着至关重要的角色。 Stack（栈）是一种后进先出（LIFO）的数据结构，这意味着最后添加的元素（压入栈的元素）会首先被取出（弹出）。在Java中，`java....
＜STL系列＞，stack和queue详解，掌握STL容器从现在开始
weixin_59371851的博客
07-17 843
哈喽大家好，今天我们继续来学习STL的容器。本章主要讲解STL中栈和队列的相关知识，小伙伴们快拿好笔记本，让我们一起开始吧。一、stack的介绍和实现（1）stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。（2）stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素。empty判空操作back获取尾部元素操作push_back尾部插入元素操作empty{...
带你深入理解STL之Stack和Queue
ZeeCoder
08-26 4605
上一篇博客，带你深入理解STL之Deque容器中详细介绍了deque容器的源码实现方式。结合前面介绍的两个容器vector和list，在使用的过程中，我们确实要知道在什么情况下需要选择恰当的容器来满足需求和提升效率。一般选择的准则有如下几条： 如果需要随机访问一个容器，vector比list要好 如果需要经常插入和删除操作的话，list比vector要好 如果既要随机存取，又要关心两端数据的插入和删
c++多线程进阶(5):线程安全的容器stack和queue
TOPEE362的博客
08-08 2737
线程安全的数据结构thread和stack
【ARM 嵌入式 C 入门及渐进26 -- 内敛函数和宏定义的区别】
CodingCos的博客
09-25 964
在 C 语言中，内联函数和宏定义都可以用来减少函数调用的开销和提高代码执行效率，但它们在许多方面存在显著区别。内联函数使用inline关键字定义。宏定义使用#define预处理指令。无类型检查：宏是文本替换，没有类型检查，可能导致类型错误。调试困难：宏替换在预处理阶段完成，难以在调试器中跟踪宏的行为。全局作用域：宏在定义后全局有效，可能引起命名冲突和作用域污染。维护复杂：宏替换简单但容易出错，逻辑复杂时难以维护。性能优化：宏是简单的文本替换，不涉及编译器优化。return 0;
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 1095
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 637
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
ubuntu22上C/C++程序使用weston+wayland+OpenGLES渲染
最新发布
Flying_Motor的博客
09-27 373
一，安装依赖软件：sudo apt install zlib1g-dev libssl-dev libgles2-mesa-dev libsystemd-dev libpng-dev libglib2.0-dev libwayland-dev weston libweston-9-dev。
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 404
【代码】求n的阶乘的相反数（c语言）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值