C++复习笔记--STL的deque容器、stack容器和queue容器

已于 2023-03-14 14:05:20 修改
阅读量343 收藏
点赞数
分类专栏： C++复习笔记 文章标签： c++ 数据结构 开发语言
于 2023-03-10 15:05:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43863869/article/details/129442152
版权

目录

1--deque容器

1-1--deque构造函数

1-2--deque赋值操作 

1-3--deque大小操作

1-4--deque的插入和删除

1-5--deque容器的存取

1-6--deque容器排序

2--stack容器

3--queue容器

1--deque容器

        deque 容器是一个双端数组，可以对头端进行插入和删除操作；

        deque 容器和 vector 容器的区别：

        vector 容器对于头部的插入删除效率低，数据量越大，效率越低；

        deque 容器对于头部的插入删除速度比 vector 容器快；

        vector 容器访问元素的速度比 deque 容器快，这与两者内部实现有关；

        deque容器内部拥有一个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据；

        中控器维护每个缓冲区的地址；deque容器的迭代器也是支持随机访问的；

1-1--deque构造函数

        使用以下函数可以实现对deque容器的构造：

deque<T> deq; // 默认构造函数

deque(beg, end); // 构造函数将[beg, end]区间中的元素拷贝到容器

deque(n, elem); // 构造函数将 n 个elem拷贝到容器

deque(const deque &deq); // 拷贝构造函数

        代码实例：

# include <iostream>
# include <deque>

void printDeuque(const std::deque<int> &d){
    for(std::deque<int>::const_iterator it = d.begin(); it < d.end(); it++){
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

void test01(){
    std::deque<int> d1;
    for(int i = 0; i < 10; i++){
        d1.push_back(i);
    }
    printDeuque(d1);

    std::deque<int> d2(d1.begin(), d1.end());
    printDeuque(d2);

    std::deque<int> d3(10, 100);
    printDeuque(d3);

    std::deque<int> d4(d3);
    printDeuque(d4);
}

int main(){
    test01();

    return 0;
}

1-2--deque赋值操作 

        通过以下函数实现对deque容器的赋值操作：

deque& operator=(const deque &deq); // 重载等号操作符

assign(beg, end); // 将 [beg, end) 区间中的数据拷贝赋值给容器

assign(n, elem); // 将 n 个 elem 拷贝赋值给容器

        代码实例：

# include <iostream>
# include <deque>

void printDeuque(const std::deque<int> &d){
    for(std::deque<int>::const_iterator it = d.begin(); it < d.end(); it++){
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

void test01(){
    std::deque<int> d1;
    for(int i = 0; i < 10; i++){
        d1.push_back(i);
    }
    printDeuque(d1);

    std::deque<int> d2 = d1;
    printDeuque(d2);

    std::deque<int> d3;
    d3.assign(d1.begin(), d1.end());
    printDeuque(d3);

    std::deque<int> d4;
    d4.assign(10, 100);
    printDeuque(d4);
}

int main(){
    test01();

    return 0;
}

1-3--deque大小操作

        通过以下函数实现对deque容器的大小操作：

deque.empty(); // 判断容器是否为空

deque.size(); // 返回容器中元素的个数

deque.resize(num); // 重新指定容器的长度为 num，若容器变长，则以默认值填充新位置。若容器变短，则末尾超出容器长度的元素将被删除；

deque.resize(num, elem); // 重新指定容器的长度为 num，若容器变长，则以 elem 值填充新位置，如果容器变短，则末尾超出容器长度的元素将被删除；

# include <iostream>
# include <deque>

void printDeuque(const std::deque<int> &d){
    for(std::deque<int>::const_iterator it = d.begin(); it < d.end(); it++){
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

void test01(){
    std::deque<int> d1;
    for(int i = 0; i < 10; i++){
        d1.push_back(i);
    }
    printDeuque(d1);

    if(d1.empty()){
        std::cout << "The deque is empty!" << std::endl;
    }
    else{
        std::cout << "The size is: " << d1.size() << std::endl;
    }

    // 重新指定大小
    d1.resize(15);
    printDeuque(d1);
    d1.resize(20, 5);
    printDeuque(d1);
}

int main(){
    test01();

    return 0;
}

1-4--deque的插入和删除

        通过以下函数向 deque 容器插入和删除数据：

两端插入操作：

        ① push_back(elem); // 在容器尾部添加一个数据

        ② push_front(elem); // 在容器头部添加一个数据

        ③ pop_back(); // 删除容器最后一个数据

        ④ pop_front(); // 删除容器第一个数据

指定位置操作：

        insert(pos, elem); // 在pos位置插入一个elem元素的拷贝，返回新数据的位置

        insert(pos, n, elem); // 在pos位置插入n个elem数据，无返回值；

        insert(pos, beg, end); // 在pos位置插入[beg, end)区间的数据，无返回值；

        clear(); // 清空容器的所有数据；

        erase(beg, end); // 删除[beg, end)区间的数据，返回下一个数据的位置；

        erase(pos); // 删除pos位置的数据，返回下一个数据的位置；

        代码：

# include <iostream>
# include <deque>

void printDeuque(const std::deque<int> &d){
    for(std::deque<int>::const_iterator it = d.begin(); it < d.end(); it++){
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

void test01(){
    std::deque<int> d1;
    // 头插和尾插
    d1.push_back(10);
    d1.push_back(20);
    d1.push_front(100);
    d1.push_front(200);
    printDeuque(d1);
    // 头删和尾删
    d1.pop_back();
    d1.pop_front();
    printDeuque(d1);
    // insert插入
    d1.insert(d1.begin(), 50);
    d1.insert(d1.begin(), 2, 20);

    std::deque<int> d2;
    d2.push_back(1);
    d2.push_back(2);
    d2.push_back(3);
    d1.insert(d1.begin(), d2.begin(), d2.end());
    printDeuque(d1);

    // 删除
    d1.erase(d1.begin(), d1.begin()+3);
    d1.erase(d1.begin());
    printDeuque(d1);
    // 清除
    d1.clear();
    printDeuque(d1);
}

int main(){
    test01();

    return 0;
}

1-5--deque容器的存取

        使用以下函数实现对deque容器数据的存取：

at(int idx); // 返回索引idx所指的数据

operator[idx]; // 返回索引idx所指的数据

front(); // 返回容器中第一个数据元素

back(); // 返回容器中最后一个数据元素

        代码：

# include <iostream>
# include <deque>

void printDeuque(const std::deque<int> &d){
    for(std::deque<int>::const_iterator it = d.begin(); it < d.end(); it++){
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

void test01(){
    std::deque<int> d1;
    d1.push_back(10);
    d1.push_back(20);
    d1.push_front(100);
    // at访问
    for(int i = 0; i < d1.size(); i++){
        std::cout << d1.at(i) << " ";
    }
    std::cout << std::endl;
    // []访问
    for(int i = 0; i < d1.size(); i++){
        std::cout << d1[i] << " ";
    }
    std::cout << std::endl;

    std::cout << "First elem: " << d1.front() << std::endl;
    std::cout << "Last elem: " << d1.back() << std::endl;
}

int main(){
    test01();

    return 0;
}

1-6--deque容器排序

        利用 sort 算法实现对deque容器的排序：

sort(iterator beg, iterator end); // 对beg和end区间内的元素进行排序

# include <iostream>
# include <deque>
# include <algorithm>

void printDeuque(const std::deque<int> &d){
    for(std::deque<int>::const_iterator it = d.begin(); it < d.end(); it++){
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

void test01(){
    std::deque<int> d1;
    d1.push_back(10);
    d1.push_back(200);
    d1.push_back(100);
    d1.push_back(20);
    d1.push_back(50);
    printDeuque(d1);
    sort(d1.begin(), d1.end());
    printDeuque(d1);
}

int main(){
    test01();

    return 0;
}

2--stack容器

        stack 容器是一种先进后出的数据结构，其只有一个出口且不允许遍历，可以计算容器的大小和判断是否为空；

        栈中进入数据称为入栈（push），而栈中弹出数据称为出栈（pop），栈容器的常用接口如下：

① 构造函数

        stack<T> stk; // stack采用模板类实现，其为stack对象的默认构造形式

        stack(const stack &stk); // 拷贝构造函数

② 赋值操作

        stack& operator=(const stack &stk); // 重载等号操作符

③ 数据存取

        push(elem); // 向栈顶添加元素

        pop(); // 从栈顶移除第一个元素

        top(); // 返回栈顶元素

④ 大小操作

        empty(); // 判断堆栈是否为空

        size(); // 返回栈的大小

        代码实例：

#include <iostream>
#include <stack>

int main(int argc, char* argv[]){
    std::stack<int> s;
    
    // 入栈
    s.push(10);
    s.push(20);
    s.push(30);
    s.push(40);

    std::cout << "The Size of Stack is: " << s.size() << std::endl;
    
    // 出栈
    while(!s.empty()){
        std::cout << "The top elem: " << s.top() << std::endl;
        s.pop();
    }
    std::cout << "The Size of Stack is: " << s.size() << std::endl;
    return 0;
}

3--queue容器

        queue 容器是一种先进先出的数据结构，其有两个出口且不允许遍历；

        队列容器允许从一侧新增元素，从另一端移除元素，只有队头和队尾可以被外界使用；

        队列中进数据称为入队（push），队列中出数据称为出队（pop），其常用接口如下：

构造函数：

        queue<T> que; // queue 容器采用模板类实现，其为queue对象的默认构造形式

        queue(const queue &que); // 拷贝构造函数

赋值操作：

        queue& operator=(const queue &que); // 重载等号操作符

数据存取：

        push(elem); // 向队尾添加元素

        pop(); // 从队头移除第一个元素

        back(); // 返回最后一个元素

        front(); // 返回第一个元素

大小操作：

        empty(); // 判断堆栈是否为空

        size(); // 返回栈的大小

        代码实例：

#include <iostream>
#include <queue>

class Person{
public:
    Person(std::string name, int age){
        this -> name = name;
        this -> age = age;
    }

    std::string name;
    int age;
};

int main(int argc, char* argv[]){

    Person p1("Zhangsan", 18);
    Person p2("Lisi", 19);
    Person p3("Wangwu", 20);

    std::queue<Person> q;
    // 入队
    q.push(p1);
    q.push(p2);
    q.push(p3);

    std::cout << "The Size of Queue is:" << q.size() << std::endl;

    // 查看队头元素和队尾元素
    while(!q.empty()){
        std::cout << "The front elem, name is: " << q.front().name 
                  << ", age is: " << q.front().age << std::endl;
        std::cout << "The back elem, name is: " << q.back().name 
                  << ", age is: " << q.back().age << std::endl;

        // 出队
        q.pop();
    }
    std::cout << "The Size of Queue is:" << q.size() << std::endl;
    return 0;
}

 

晓晓纳兰容若
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[C++] 使用 deque 模拟实现栈（stack）
giturtle's blog
08-29 518
template<class T, class Container = deque<int>> class Stack{ public: void Push(const T& x){ _con.push_back(x); } void Pop(){ _con.pop_back(); } size_t Size() const{ return...
c++ STL中的五种序列式容器
figting
09-18 560
c++ STL中的五种序列式容器 序列式容器 序列容器，即以线性排列（类似普通数组的存储方式）来存储某一指定类型（例如 int、double 等）的数据，需要特殊说明的是，该类容器并不会自动对存储的元素按照值的大小进行排序。 序列容器大致包含以下几类容器： array<T,N>（数组容器）：表示可以存储 N 个 T 类型的元素，是 C++ 本身提供的一种容器。此类容器一旦建立，其长度就是固定不变的，这意味着不能增加或删除元素，只能改变某个元素的值； vector（向量容器）：用来
std::deque、std::queue、std::stack、std::list 内容概要
alphaCat的专栏
10-09 7303
deque deque的简介 deque是“double-ended queue”的缩写，和vector一样都是STL的容器，deque是双端的，而vector是单端的。 deque在接口上和vector非常相似，在许多操作的地方可以直接替换。 deque可以随机存取元素（支持索引值直接存取， 用[]操作符或at()方法，这个等下会详讲）。 deque头部和尾部添加或移除元素都非常快速。但是在中...
C++栈和队列之(deque)模拟实现
weixin_45806964的博客
11-15 284
#include<iostream> #include<vector> #include<stack> #include<queue> #include<deque> #include<algorithm> using namespace std; namespace bit { #include<deque> template<class T, class Con = deque<T>>
Queue和Deque区别
最新发布
m0_58218015的博客
12-12 190
Queue和Deque（双端队列）都是数据结构，它们在计算机科学中用于存储和操作一组对象。尽管它们有相似之处，但它们在操作和用途上有一些重要的区别。
C++ STL容器stack和queue详解
09-01
C++ STL（Standard Template Library，标准模板库）提供了两种特殊的线性容器：stack（栈）和queue（队列），它们都是基于顺序容器（如vector或deque）实现的抽象数据类型，用于实现特定的数据操作逻辑。 **1. ...
C++ - SGI 版本 STL源码
10-25
**C++ SGI版STL源码详解** STL（Standard Template ...这对于提升C++编程技能，优化代码性能，以及自定义STL容器和算法都大有裨益。在实际项目中，理解和利用STL可以提高代码的可读性和可维护性，降低开发复杂度。
深入解析C++ STL中的常用容器
09-05
C++ STL（Standard Template Library，标准模板库）是C++编程中不可或缺的一部分，它提供了大量高效的数据结构和算法。在STL中，容器是用于存储和管理数据的主要工具。本篇文章将深入解析C++ STL中的一些常用容器，...
STL常用容器详细解析
09-05
本文主要探讨STL中的常用容器，包括顺序性容器（vector、deque、list）、关联容器（map、set）以及容器适配器（queue、stack）。 1. 顺序性容器 - (1) vector vector是一种动态数组，其内存空间是连续的，支持...
cPP.rar_c++ 容器使用_容器
09-19
首先，C++中的容器分为几种主要类型：顺序容器（如vector、deque和list）、关联容器（如set、multiset、map和multimap）以及特殊容器（如stack、queue和priority_queue）。每个容器都有其特定的用途和性能特点。 1....
C++ 学习（18）STL - deque容器、stack容器、queue容器
ling1998的博客
08-02 607
本章主要学习： deque容器及常用接囗（构造函数、赋值操作、大小操作、插入和删除、数据读取、排序）、stack容器及常用接囗（构造函数、赋值操作、数据存取、大小操作）、queue容器及常用接囗（构造函数、赋值操作、数据存取、大小操作）...
STL--deque、stack、queue
weixin_44627813的博客
05-01 2218
一、deque介绍 deque(双端队列)：是一种双开口的“连续”空间的数据结构。双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不必搬动数据；与list相比，空间利用比较高。 deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组，其底层结构如下图： deque采用一块所谓的map(注意：不是STL的map容器)作为主控，这里的map是一小块连续空间，其中每个元素都是一个指针，指向另一段（
队列 std::queue 双端队列 std::deque，优先级队列 std::priorty_queue
qq_38349382的博客
09-24 126
一、双端队列 std::deque 中文标准库：std::deque 转载：STL源码剖析——deque的实现原理和使用方法详解 vector sizeof(deque) std::deque(double-ended queue)双端队列，是有下标的顺序容器。它允许在其首尾两端快速插入及删除。另外，在deque任一端插入或删除不会非法化指向其余元素的指针或引用(例如vector删除第一个元素，...
C++ STL之 queue和deque用法详解
zdlzf的博客
05-25 7823
C++ queue和deque用法详解 deque可以队首和队尾插入，也可以队首和队尾弹出，支持随机访问，即可以直接用下标来访问元素。它和vector有点像，因为它可以index索引和at()函数索引，当然，也可以迭代器索引。此外，它可以进行指定尺寸的构造-queue就不可以指定尺寸构造。
STL之queue容器详解
专注【PostgreSQL源码学习&研究】
04-15 3604
文章目录1. queue概念2. queue成员函数2.1 queue示例程序3. queue应用场景4. queue源码5. queue如何有效清空内存空间6. queue线程安全吗？7. 总结 1. queue概念      queue是一种提供FIFO（先进先出）行为的标准容器，它满足容器的大多数要求。本质它不是真正的容器，而是一个适配器。因为它并未定义与迭代器有关的任何内容及接口。它持有另...
C++ queue 和 deque的区别
热门推荐
南方以北
04-06 1万+
从使用的角度来讲主要差别就是： deque支持push_front、pop_front、push_back、pop_back。 queue支持push_back、pop_front。 ---------------------------------------------------------------------------- deque是双端队列 #include<de...
【STL详解】queue和deque
这是简介
07-01 702
【STL详解】queue和deque
C/C++编程：STL双端队列deque的使用
OceanStar的博客
08-03 1187
头文件：#include&lt;queue&gt; 实例化： queue&lt;类型[, 存储容器]&gt;QueueName 成员函数： boolempty(); 队列为空返回 true否则返回false. voidpop(); 删除队列的一个元素。 voidpush( constTY...
std::Deque使用总结
大山喵写博客的地方
10-12 1万+
Deque
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值