C++ deque/queue/stack的底层原理

**C++ deque、queue 和 stack 的底层原理**

在 C++ 中，deque（双端队列）、queue（队列）和 stack（堆栈）都是常用的线性数据结构。它们都支持元素的插入和删除操作，但它们的实现细节却有所不同。在本文中，我们将探讨这些数据结构的底层原理，并提供相关代码示例。

###1. deque 的底层原理deque（双端队列）是 C++ 中一种特殊的线性数据结构，它支持从两端插入和删除元素。deque 的底层实现基于一个动态数组和两个指针：`front_` 和 `back_`。

cpptemplate <typename T>
class deque {
public:
 // ...

private:
 T* data_; // 动态数组，存储元素 size_t front_; // 前端指针 size_t back_; // 后端指针 void init(size_t n) { // 初始化动态数组和指针 data_ = new T[n];
 front_ =0;
 back_ =0;
 }

 ~deque() { delete[] data_; } // 析构函数，释放动态数组 void push_front(const T& x) { // 从前端插入元素 if (front_ ==0) {
 init(1);
 }
 size_t newFront = front_;
 --newFront;
 data_[newFront] = x;
 front_ = newFront;
 }

 void push_back(const T& x) { // 从后端插入元素 if (back_ == capacity()) {
 init(capacity() *2);
 }
 size_t newBack = back_;
 ++newBack;
 data_[newBack] = x;
 back_ = newBack;
 }

 T pop_front() { // 从前端删除元素 if (front_ == back_) {
 delete[] data_;
 front_ =0;
 back_ =0;
 }
 size_t oldFront = front_;
 ++oldFront;
 T x = data_[oldFront];
 front_ = oldFront;
 return x;
 }

 T pop_back() { // 从后端删除元素 if (front_ == back_) {
 delete[] data_;
 front_ =0;
 back_ =0;
 }
 size_t oldBack = back_;
 --oldBack;
 T x = data_[oldBack];
 back_ = oldBack;
 return x;
 }

 // ...
};

在上面的代码中，我们可以看到 deque 的底层实现基于一个动态数组和两个指针：`front_` 和 `back_`。当从前端插入元素时，会将新元素放置在当前的 `front_` 指向的位置之前；当从后端插入元素时，会将新元素放置在当前的 `back_` 指向的位置之后。当从前端或后端删除元素时，会将 `front_` 或 `back_` 指针移动到下一个位置。

###2. queue 的底层原理queue（队列）是 C++ 中一种特殊的线性数据结构，它支持从一端插入和删除元素。queue 的底层实现基于一个动态数组和两个指针：`front_` 和 `back_`。

cpptemplate <typename T>
class queue {
public:
 // ...

private:
 T* data_; // 动态数组，存储元素 size_t front_; // 前端指针 size_t back_; // 后端指针 void init(size_t n) { // 初始化动态数组和指针 data_ = new T[n];
 front_ =0;
 back_ =0;
 }

 ~queue() { delete[] data_; } // 析构函数，释放动态数组 void push(const T& x) { // 从后端插入元素 if (back_ == capacity()) {
 init(capacity() *2);
 }
 size_t newBack = back_;
 ++newBack;
 data_[newBack] = x;
 back_ = newBack;
 }

 T pop() { // 从前端删除元素 if (front_ == back_) {
 delete[] data_;
 front_ =0;
 back_ =0;
 }
 size_t oldFront = front_;
 ++oldFront;
 T x = data_[oldFront];
 front_ = oldFront;
 return x;
 }

 // ...
};

在上面的代码中，我们可以看到 queue 的底层实现基于一个动态数组和两个指针：`front_` 和 `back_`。当从后端插入元素时，会将新元素放置在当前的 `back_` 指向的位置之后。当从前端删除元素时，会将 `front_` 指针移动到下一个位置。

###3. stack 的底层原理stack（堆栈）是 C++ 中一种特殊的线性数据结构，它支持从一端插入和删除元素。stack 的底层实现基于一个动态数组和一个指针：`top_`。

cpptemplate <typename T>
class stack {
public:
 // ...

private:
 T* data_; // 动态数组，存储元素 size_t top_; // 顶部指针 void init(size_t n) { // 初始化动态数组和指针 data_ = new T[n];
 top_ =0;
 }

 ~stack() { delete[] data_; } // 析构函数，释放动态数组 void push(const T& x) { // 从顶部插入元素 if (top_ == capacity()) {
 init(capacity() *2);
 }
 size_t newTop = top_;
 ++newTop;
 data_[newTop] = x;
 top_ = newTop;
 }

 T pop() { // 从顶部删除元素 if (top_ ==0) {
 delete[] data_;
 top_ =0;
 }
 size_t oldTop = top_;
 --oldTop;
 T x = data_[oldTop];
 top_ = oldTop;
 return x;
 }

 // ...
};

在上面的代码中，我们可以看到 stack 的底层实现基于一个动态数组和一个指针：`top_`。当从顶部插入元素时，会将新元素放置在当前的 `top_` 指向的位置之后。当从顶部删除元素时，会将 `top_` 指针移动到上一个位置。

综上所述，我们可以看到 deque、queue 和 stack 的底层原理都是基于动态数组和指针实现的。它们都支持元素的插入和删除操作，但它们的实现细节却有所不同。在实际应用中，选择合适的数据结构是非常重要的。