【 C++ STL-Deque的实现】

原创 已于 2025-07-21 10:26:52 修改 · 297 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言 #stl

于 2025-07-21 10:24:42 首次发布

C++ STL-Deque的实现

中控指针数组

  1. 本质上是一个指向指针的指针
  2. 它保存的是多个指向内存块（缓冲区/缓冲段）的指针
  3. 这些内存块每个保存固定数量的元素

缓冲区

  1. 每个缓冲区用于存放真正的数据。
  2. 不同缓冲区在内存中不一定连续，因此 deque 可以有效地从两端插入或删除元素

Deque的内部结构采用分段数组，而不是简单的连续数组
deque的内部结构利用了多个缓冲区，有助于提高内存局部性，不同缓冲区在内存中不一定连续，因此 deque 可以有效地从两端插入或删除元素

deque的大小可以动态调整，无需事先分配固定大小的内存
deque 允许在常量时间内对元素进行随机访问，这意味着可以通过索引直接访问deque中的元素，而不会随deque的大小而增加访问时间

1.Deque成员变量定义

private:
   T* elements;        //数组指针
   size_t capacity;    //容量
   size_t frontIndex;  //Deque的头索引
   size_t backIndex;   //Deque的尾索引
   size_t size;        //Deque的元素数量

2.Deque构造函数

Deque() : elements(nullptr), capacity(0), frontIndex(0), backIndex(0), size(0) {}

3.Deque析构函数

~Deque()
{
    clear(); //clear在后面介绍
    delete[] elements;
}

4.从Deque前端清除元素

void pop_front()
{
    //判断Deque是否非空
    if(size == 0)
    {
        throw out_of_range("Deque if empty!");
    }
    //使用%capacity的原因是当 frontIndex 到达数组末尾（最大索引）时，回绕回到数组起点，实现环形行为（循环利用数组空间），防止访问越界，避免未定义行为
    frontIndex = (frontIndex + 1) % capacity;
    //更新元素数量
    --size;
}

5.从Deque后端清除元素

//从Deque后端清除元素
void pop_back()
{
    //判断Deque是否非空
    if(size == 0)
    {
        throw out_of_range("Deque if empty!");
    }
    backIndex = (backIndex - 1 + capacity) % capacity;
    //更新元素数量
    --size;
}

6.在Deque前端插入新元素

//在Deque前端插入新元素
void push_front(const T& value)
{
    //判断元素数量是否已达到容器总量
    if(size == capacity)
    {
        resize();
    }
    //计算插入的新元素后前端的新的索引值
    frontIndex = (frontIndex - 1 + capacity) % capacity;
    elements[frontIndex] = value;
    //更新元素总数
    ++size;
}

7.在Deque后端插入元素

//在Deque后端插入元素
void push_back(const T& value)
{
    //判断元素数量是否已达到容器总量
    if(size == capacity)
    {
      resize();
    }
    //直接调用elements[backIndex]的原因是backIndex所指向的是最后一个元素的后面一个位置
    elements[backIndex] = value;
    backIndex = (backIndex + 1) % capacity;
    //更新元素总数
    ++size;
}

8.清空Deque

//清空Deque
void clear()
{
    while(size > 0 )
    {
        pop_front();
    }
}

9.[]运算符重载: 以提供Deque访问能力

//[]运算符重载: 以提供Deque访问能力
T& operator[] (int index)
{
    //判断越界行为
    if(index < 0 || index >= size)
    {
        throw out_of_range("Index out of range");
    }
    return elements[(frontIndex + index) % capacity];
}

10.获取Deque元素数量

//Deque元素总数
size_t getSize() const
{
    return size;
}

11.数组扩容：resize

private:
    //数组扩容
    void resize()
    {
        //判断是否是0
        size_t newCapacity = (capacity == 0) ? 1 : capacity*2;
        //创建新的数组用于放置原来的数组元素

        T* newELements = new T[newCapacity];

        size_t index = frontIndex;
        for(size_t i= 0; i < size; ++i)
        {
            newELements[i] = elements[index];
            index = (index + 1) % capacity;
        }

        //释放原始数组的内存
        delete[] elements;

        //扩容后的数组成员变量更新
        elements = newELements;
        capacity = newCapacity;
        frontIndex = 0;
        backIndex = size;
    }

12.打印Deque中的元素

//print Deque中的所有元素
void printElements() const
{
    size_t index = frontIndex;
    for(size_t i = 0; i < size; ++i)
    {
        cout << elements[index] << " ";
        index = (index + 1) % capacity;
    }
    cout << endl;
}

13.C++完整代码实现

#include <iostream>
#include <algorithm>
#include <string>
#include <sstream>
#include <stdexcept>
using namespace std;

template <typename T>
class Deque
{
    private:
        T* elements;        //数组指针
        size_t capacity;    //容量
        size_t frontIndex;  //Deque的头索引
        size_t backIndex;   //Deque的尾索引
        size_t size;        //Deque的元素数量


        //数组扩容
        void resize()
        {
            //判断是否是0
            size_t newCapacity = (capacity == 0) ? 1 : capacity*2;
            //创建新的数组用于放置原来的数组元素

            T* newELements = new T[newCapacity];

            size_t index = frontIndex;
            for(size_t i= 0; i < size; ++i)
            {
                newELements[i] = elements[index];
                index = (index + 1) % capacity;
            }

            //释放原始数组的内存
            delete[] elements;

            //扩容后的数组成员变量更新
            elements = newELements;
            capacity = newCapacity;
            frontIndex = 0;
            backIndex = size;
        }
    public:
        //Deque构造函数
        Deque() : elements(nullptr), capacity(0), frontIndex(0), backIndex(0), size(0) {}

        //析构函数
        ~Deque()
        {
            clear();
            delete[] elements;
        }

        //从Deque前端清除元素
        void pop_front()
        {
            //判断Deque是否非空
            if(size == 0)
            {
                throw out_of_range("Deque if empty!");
            }
            //使用%capacity的原因是当 frontIndex 到达数组末尾（最大索引）时，回绕回到数组起点，实现环形行为（循环利用数组空间），防止访问越界，避免未定义行为
            frontIndex = (frontIndex + 1) % capacity;
            //更新元素数量
            --size;
        }

        //从Deque后端清除元素
        void pop_back()
        {
            //判断Deque是否非空
            if(size == 0)
            {
                throw out_of_range("Deque if empty!");
            }
            backIndex = (backIndex - 1 + capacity) % capacity;
            //更新元素数量
            --size;
        }

        //在Deque前端插入新元素
        void push_front(const T& value)
        {
            //判断元素数量是否已达到容器总量
            if(size == capacity)
            {
                resize();
            }
            //计算插入的新元素后前端的新的索引值
            frontIndex = (frontIndex - 1 + capacity) % capacity;
            elements[frontIndex] = value;
            //更新元素总数
            ++size;
        }

        //在Deque后端插入元素
        void push_back(const T& value)
        {
            //判断元素数量是否已达到容器总量
            if(size == capacity)
            {
              resize();
            }
            //直接调用elements[backIndex]的原因是backIndex所指向的是最后一个元素的后面一个位置
            elements[backIndex] = value;
            backIndex = (backIndex + 1) % capacity;
            //更新元素总数
            ++size;
        }

        //[]运算符重载: 以提供Deque访问能力
        T& operator[] (int index)
        {
            //判断越界行为
            if(index < 0 || index >= size)
            {
                throw out_of_range("Index out of range");
            }
            return elements[(frontIndex + index) % capacity];
        }

        //Deque元素总数
        size_t getSize() const
        {
            return size;
        }

        //清空Deque
        void clear()
        {
            while(size > 0 )
            {
                pop_front();
            }
        }

        //print Deque中的所有元素
        void printElements() const
        {
            size_t index = frontIndex;
            for(size_t i = 0; i < size; ++i)
            {
                cout << elements[index] << " ";
                index = (index + 1) % capacity;
            }
            cout << endl;
        }

};

int main()
{
    Deque<int> myDeque;

    //总共几条命令
    int N;
    cin >> N;
    getchar();
    string line;

    for(int i = 0; i < N; i++)
    {
        getline(cin,line);
        istringstream iss(line);
        string command;
        iss >> command;
        int value;

        if(command == "push_back")
        {
            iss >> value;
            myDeque.push_back(value);
        }
        if(command == "push_front")
        {
            iss >> value;
            myDeque.push_front(value);
        }
        if (command == "pop_back") 
        {
            if (myDeque.getSize() == 0) 
            {
                continue;
            }
            myDeque.pop_back();
        }

        if (command == "pop_front") 
        {
            if (myDeque.getSize() == 0) 
            {
                continue;
            }
            myDeque.pop_front();
        }

        if (command == "clear") 
        {
            myDeque.clear();
        }

        if (command == "size") 
        {
            cout << myDeque.getSize() << endl;
        }

        if (command == "get") 
        {
            iss >> value;
            cout << myDeque[value] << endl;
        }
        if (command == "print") 
        {
            if (myDeque.getSize() == 0) 
            {
                cout << "empty" << endl;
            } 
            else 
            {
                myDeque.printElements();
            }
        }
    }
    return 0;
}

14.运行结果

在这里插入图片描述

嵇月白
关注
deque C++实现
Flood_flowing SYN
05-31 2043
模仿源码，对deque进行了实现。
【十八】【C++】deque双端队列简单使用和deque底层实现探究（部分代码）
m0_74163972的博客
02-14 1490
struct __deque_iterator {//deque迭代器定义了一个模板，T是数据类型，Ref是引用类型，Ptr是指针类型，BufSiz是缓冲区大小。定义了一个结构体，作为deque的迭代器。//结点的大小//结点指针定义了迭代器和常量迭代器类型，分别用于修改和访问deque元素。定义了一个静态成员函数，用来计算每个缓冲区的大小。定义了为。这表示是一个随机访问迭代器，支持像数组一样的快速随机访问。
Deque：使用C ++实现数据结构Deque的实现
02-17
双端队列 使用C ++实现数据结构双端队列的实现。 详细信息可以在deque.hpp中查看。 除了该文件之外，还有一些测试示例可以验证双端队列的可靠性和时间效率。 自己检查。
C++ deque实现
liufangping的博客
10-05 1129
deque是序列式容器中设计难度最大的容器，主要原因在于其特殊的数据结构和配套的迭代器设计（从deque的设计中可以看出每种容器只能由自己来设计迭代器）。 其内部首先以一块连续的空间作为map，map内的每个node指向一块连续的缓冲区，这些连续的缓冲区才是真正存放数据的位置，初始状态是它维护一个空的缓冲区，当一块缓冲区满时，需要申请一块新的缓冲区，并通过map内的一个node记录其位置，当map...
C++ deque底层实现
bob的博客
08-22 2378
deque容器的存储结构 和 vector 容器采用连续的线性空间不同，deque 容器存储数据的空间是由一段一段等长的连续空间构成，各段空间之间并不一定是连续的，可以位于在内存的不同区域。 为了管理这些连续空间，deque 容器用数组（数组名假设为 map）存储着各个连续空间的首地址。也就是说，map 数组中存储的都是指针，指向那些真正用来存储数据的各个连续空间（如图 1 所示）。 图1 deque容器的底层存储机制 通过建立 map 数组，deque 容器申请的这些分段的连续空间就能实现“整体连续”的
stl-deque.h (C++STL deque的源码)
10-22
在C++ STL deque的源码中，我们会看到多个类和函数的定义和实现。首先，deque类本身提供了一系列的成员函数，如size(), empty(), push_back(), push_front(), pop_back(), pop_front(), insert(), erase(), front(),...
deque.h (包含stl-deque.h的头文件)
10-22
STL deque的实现还考虑了多线程环境下的线程安全性，尽管C++标准并未明确指定这些要求，但在实际编译器的实现中，通常会尽量保证其线程安全性。 deque的性能特点让它成为了在需要动态数组特性，但又不希望像vector...
【C++入门到精通】C++入门 - deque(STL)
08-21
【C++入门到精通】C++入门 - deque(STL)
C++STL-stack和queue的使用及底层实现
最新发布
09-01
C++STL中的stack和queue容器适配器都提供了强大的成员函数来管理其内部的元素。例如，stack提供了size、empty和swap等成员函数。size函数返回栈中元素的数量，empty函数检查栈是否为空，swap函数可以交换两个栈的...
C++ deque 原理详解：内部实现机制与性能分析
嗨，欢迎来到我的 CSDN 博客小天地！一名深耕多年的技术发烧友。在这里，我将把日常工作中积累的宝贵经验，从复杂架构设计的精妙之处，到代码优化的实战技巧，毫无保留地分享给大家。
05-04 788
C++ deque 原理详解：内部实现机制与性能分析
【C++】deque的实现原理简单介绍
一点一点变好
04-22 4186
【C++】deque的实现原理简单介绍
类STL deque实现 C++
qq_44465615的博客
06-16 383
第一章Deque实现 1.1deque概述 deque是一个双向开口的连续线性空间，可以在首尾两头在头尾两端分别做元素的插入和删除操作，如图1所示。 deque可以在常数字时间内对头端进行元素的插入和移除操作。同时，其没有容量概念，因为是动态地以分段地址形式组合形成的，随时可以增加一段新的空间并链接起来。 虽然deque可以实现快速对首尾进行读取，但是对其中间数据的读取较为困难，需要O(n)的时间复杂度。 1.2deque原理 deque是由一段一段的定量连续空间构成的，一旦有必要在deque的前端或尾端
双端队列（Deque）的原理与C++实现详解
m0_75082047的博客
08-04 1928
/ 队列中元素的类型// 双端队列的节点结构// 数据域// 前驱指针// 后继指针// 双端队列结构// 队头指针（指向头结点）PNode rear;// 队尾指针} Deque;DNode：双向链表节点，包含数据域data和两个指针域（prev和nextDeque：双端队列的管理结构，包含front（队头指针）和rear（队尾指针）使用typedef简化类型名，提高代码可读性双端队列作为一种灵活的数据结构，结合了栈和队列的特性，在需要从两端操作元素的场景中表现出色。
【C++】STL之deque容器的简单实现
qq_43411563的博客
07-25 1796
deque容器 一、deque容器是C++标准模版库STL中的部分内容。deque容器类与vector类似，支持随机访问和快速插入删除，它在容器中某一位置上的操作所花费的是线性时间。与vector不同的是，deque还支持从开始端插入数据：push_front()。 二、deque容器的底部是一个双端队列。双端队列的好处就是两端都可以进行插入和删除。但deque容器的底层确实一个受限的双端队列，也就是，如果在头部进行插入的话尾部就只能进行删除操作。如果在头部进行删除的话尾部就只能进行插入的操作。也就是头部只
【C++】对容器适配器（deque),优先级队列（priority_queue）的认识与实现
KL4180的博客
04-08 245
C++ 容器适配器（deque),优先级队列（priority_queue）
C++中的deque详解
Weirdo的博客
06-05 7638
本文详细介绍了C++中的deque容器，包括其基本特性、基本操作、内存管理以及应用场景。通过示例代码，读者可以更加深入地了解deque的使用方法和性能特点。在实际编程中，根据具体需求选择适合的容器类型是非常重要的。
单调队列（利用C++容器deque实现）原理解析
小吴同学的博客
04-09 1537
1：关于deque *deque是C++中的一个容器，其底层原理是双端队列（学过数据结构的应该知道，就是对比于普通的队列而言，可以在双端队列的两端进行插入和删除操作，所以用它来操作数据比较方便，但是注意：其底层存储结构并不是连续的存储单元，所以不能用指针加偏移地址去操作）。 * 其头文件为#include< queue > 2:关于单调队列 单调队列其实是一种思想，也就是维护一个...
C++ deque 深度解析：属性、方法、底层实现与扩容机制
m0_73740524的博客
04-27 1249
高效两端操作：头部/尾部插入/删除均为O(1)分段连续存储：平衡内存局部性与动态扩展性复杂迭代器设计：支持跨缓冲区遍历的特殊实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值