C++ deque 原理详解：内部实现机制与性能分析

于 2025-05-04 01:00:00 发布
阅读量489 收藏 11
点赞数 11
分类专栏： c++ 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16242613/article/details/147624127
版权

文章目录

一、deque 的基本概念

deque（双端队列，全称 double-ended queue）是 C++ STL 中的一种序列式容器，它允许在头部和尾部高效地进行插入和删除操作。与 vector 相比，deque 在头部插入/删除的时间复杂度为 O(1)，而 vector 为 O(n)。

1.1 deque 的主要特性

  • 双端操作：支持在头部和尾部高效插入/删除
  • 随机访问：支持通过下标直接访问元素（O(1) 时间复杂度）
  • 动态扩容：自动管理内存，根据需要动态增长
  • 非连续存储：元素并非存储在单一连续内存块中

二、deque 的内部实现原理

2.1 deque 的数据结构

deque 通常采用"分段连续"的存储方式，具体实现为一个"中央控制器"（map）和多个缓冲区（buffer）：

template <class T>
class deque {
private:
    T** map;          // 指向指针数组的指针（中央控制器）
    size_t map_size;  // map 的大小
    iterator start;   // 指向第一个元素的迭代器
    iterator finish;  // 指向最后一个元素的下一个位置的迭代器
    // ...
};

2.2 deque 的迭代器设计

deque 的迭代器比 vector 的迭代器复杂得多，因为它需要跨越不同的缓冲区：

template <class T>
struct __deque_iterator {
    T* cur;           // 当前元素指针
    T* first;         // 当前缓冲区的起始位置
    T* last;          // 当前缓冲区的结束位置
    T** node;         // 指向中央控制器中当前缓冲区指针的位置
    // ...
};

2.3 deque 的内存布局

deque 的内存布局可以形象地表示为：

中央控制器 (map)
+---+---+---+---+---+---+---+
| * | * | * | * | * | * | * |
+---+---+---+---+---+---+---+
 |   |   |   |   |   |   |
 v   v   v   v   v   v   v
+---+ +---+ +---+ +---+ +---+
|B1| |B2| |B3| |B4| |B5| ...
+---+ +---+ +---+ +---+ +---+

每个缓冲区（B1, B2等）存储实际元素，中央控制器中的指针指向这些缓冲区。

三、deque 的核心操作实现

3.1 插入操作

头部插入（push_front）
void push_front(const value_type& value) {
    if (start.cur != start.first) {
        // 当前缓冲区还有空间
        construct(start.cur - 1, value);
        --start.cur;
    } else {
        // 需要分配新缓冲区
        reserve_map_at_front();
        *(start.node - 1) = allocate_node();
        start.set_node(start.node - 1);
        start.cur = start.last - 1;
        construct(start.cur, value);
    }
}
尾部插入（push_back）
void push_back(const value_type& value) {
    if (finish.cur != finish.last - 1) {
        // 当前缓冲区还有空间
        construct(finish.cur, value);
        ++finish.cur;
    } else {
        // 需要分配新缓冲区
        reserve_map_at_back();
        *(finish.node + 1) = allocate_node();
        finish.set_node(finish.node + 1);
        finish.cur = finish.first;
        construct(finish.cur, value);
        ++finish.cur;
    }
}

3.2 删除操作

头部删除（pop_front）
void pop_front() {
    if (start.cur != start.last - 1) {
        // 当前缓冲区还有元素
        destroy(start.cur);
        ++start.cur;
    } else {
        // 需要切换到前一个缓冲区
        destroy(start.cur);
        deallocate_node(start.first);
        start.set_node(start.node + 1);
        start.cur = start.first;
    }
}
尾部删除（pop_back）
void pop_back() {
    if (finish.cur != finish.first) {
        // 当前缓冲区还有元素
        --finish.cur;
        destroy(finish.cur);
    } else {
        // 需要切换到前一个缓冲区
        deallocate_node(finish.first);
        finish.set_node(finish.node - 1);
        finish.cur = finish.last - 1;
        destroy(finish.cur);
    }
}

3.3 随机访问

reference operator[](size_type n) {
    return start[difference_type(n)];
}

reference front() { return *start; }
reference back() {
    iterator tmp = finish;
    --tmp;
    return *tmp;
}

四、deque 的扩容机制

4.1 中央控制器扩容

当中央控制器的空间不足时，deque 会重新分配一个更大的中央控制器：

void reserve_map_at_back(size_type nodes_to_add = 1) {
    if (nodes_to_add + 1 > map_size - (finish.node - map))
        reallocate_map(nodes_to_add, false);
}

void reserve_map_at_front(size_type nodes_to_add = 1) {
    if (nodes_to_add > start.node - map)
        reallocate_map(nodes_to_add, true);
}

4.2 缓冲区分配

每个缓冲区的大小通常是固定的，不同实现可能有不同策略。例如，GCC 的实现中：

inline size_t __deque_buf_size(size_t size) {
    return size < 512 ? size_t(512 / size) : size_t(1);
}

五、deque 与 vector 的对比

特性dequevector
内部结构分段连续存储单一连续内存块
头部插入/删除O(1)O(n)
尾部插入/删除O(1)平摊 O(1)
中间插入/删除O(n)O(n)
随机访问O(1)O(1)
迭代器失效插入/删除可能导致失效插入/删除通常导致失效
内存使用更高（有额外指针开销）更低
缓存局部性较差优秀

六、deque 的应用示例

6.1 基本操作示例

#include <iostream>
#include <deque>

int main() {
    std::deque<int> dq;
    
    // 头部和尾部插入
    dq.push_back(1);
    dq.push_front(2);
    dq.push_back(3);
    dq.push_front(4);
    
    // 输出: 4 2 1 3
    for (int num : dq) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    // 随机访问
    std::cout << "Element at index 2: " << dq[2] << std::endl;
    
    // 头部和尾部删除
    dq.pop_front();
    dq.pop_back();
    
    // 输出: 2 1
    for (int num : dq) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

6.2 性能测试示例

#include <iostream>
#include <deque>
#include <vector>
#include <chrono>

const int TEST_SIZE = 1000000;

void test_deque() {
    std::deque<int> dq;
    auto start = std::chrono::high_resolution_clock::now();
    
    for (int i = 0; i < TEST_SIZE; ++i) {
        dq.push_front(i);
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> diff = end - start;
    std::cout << "deque push_front time: " << diff.count() << " s\n";
}

void test_vector() {
    std::vector<int> vec;
    auto start = std::chrono::high_resolution_clock::now();
    
    for (int i = 0; i < TEST_SIZE; ++i) {
        vec.insert(vec.begin(), i);
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> diff = end - start;
    std::cout << "vector insert at begin time: " << diff.count() << " s\n";
}

int main() {
    test_deque();
    test_vector();
    return 0;
}

七、deque 的迭代器失效问题

deque 的迭代器失效规则比 vector 复杂：

  1. 插入操作：

    • 在头部或尾部插入：通常不会使任何迭代器失效
    • 在中间插入：会使所有迭代器失效

  2. 删除操作：

    • 在头部或尾部删除：通常只使指向被删除元素的迭代器失效
    • 在中间删除：会使所有迭代器失效

  3. 扩容操作：

    • 中央控制器扩容会使所有迭代器失效
#include <iostream>
#include <deque>

int main() {
    std::deque<int> dq = {1, 2, 3, 4, 5};
    auto it = dq.begin() + 2; // 指向3
    
    dq.push_back(6); // 不影响迭代器
    std::cout << *it << std::endl; // 输出3
    
    dq.push_front(0); // 不影响迭代器
    std::cout << *it << std::endl; // 输出3
    
    dq.insert(dq.begin() + 1, 9); // 使所有迭代器失效
    // std::cout << *it << std::endl; // 未定义行为
    
    return 0;
}

八、deque 的优缺点分析

8.1 优点

  1. 高效的双端操作：在头部和尾部插入/删除都是 O(1) 时间复杂度
  2. 动态扩容：不需要预先指定大小
  3. 随机访问：支持通过下标快速访问元素
  4. 内存效率：相比 vector，扩容时不需要移动所有元素

8.2 缺点

  1. 内存不连续：缓存局部性不如 vector
  2. 内存开销：需要维护中央控制器和多个缓冲区
  3. 中间操作性能：在中间插入/删除效率不高
  4. 迭代器失效：规则复杂，容易出错

九、deque 的最佳实践

  1. 适合场景：

    • 需要频繁在头部和尾部插入/删除
    • 需要随机访问但不需要最高性能
    • 不确定元素数量但需要高效两端操作

  2. 避免场景：

    • 需要最高性能的随机访问
    • 需要内存连续性的场景（如与C API交互）
    • 需要频繁在中间位置插入/删除

  3. 性能优化：

    • 如果知道大致元素数量，可以使用构造函数预分配空间
    std::deque<int> dq(1000); // 预分配空间
    • 避免不必要的中间插入/删除
    • 考虑使用 vector 如果只需要尾部操作

十、总结

deque 是 C++ STL 中一个功能强大的双端队列容器，它通过分段连续的存储方式实现了高效的双端操作和随机访问能力。理解 deque 的内部实现机制对于正确使用和优化性能至关重要。虽然 deque 在某些方面不如 vector 高效，但在需要频繁双端操作的场景下，它是无可替代的选择。

通过本文的详细分析，读者应该能够：

  1. 理解 deque 的内部实现原理
  2. 掌握 deque 的核心操作及其时间复杂度
  3. 了解 deque 与 vector 的差异及适用场景
  4. 避免常见的迭代器失效问题
  5. 在实际开发中合理选择和使用 deque

在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北辰alk

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值