C++栈和队列

---徐乾---

已于 2024-05-05 21:43:08 修改

阅读量65

点赞数

分类专栏： C++ 文章标签： c++ 开发语言

于 2023-08-14 12:17:38 首次发布

本文链接：https://blog.csdn.net/m0_62229058/article/details/131688296

版权

C++ 专栏收录该内容

38 篇文章 0 订阅

订阅专栏

4. priority_queue的介绍和使用

5.2. STL标准库中的stack和queue

5.3. 了解deque

5.4. deque 的总结

1. stack的介绍和使用

std::stack
template <class T, class Container = deque<T> > class stack;

1.1. 介绍

stack 是一种容器适配器，专门用在具有后进先出(LIFO)操作的上下文环境中，其删除只能从容器的一端进行元素的插入与删除操作；
stac k是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素；
stack 的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：
empty：判空操作；
top：获取栈顶元素操作；
push：向栈顶插入元素操作；
pop：从栈顶删除元素操作。
标准容器 vector、deque、list 均符合这些需求，默认情况下，如果没有为 stack 指定特定的底层容器，默认情况下使用deque。

1.2. 使用

测试 demo 如下：

void Test1(void)
{
	std::stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	st.push(4);
	st.push(5);
	std::cout << "stack size = " << st.size() << std::endl;
	//遍历数据要符合LIFO的原则
	while (!st.empty())
	{
		std::cout << st.top() << " ";
		st.pop();
	}
	std::cout << std::endl;
}

现象如下：

1.3. 练习题

第一题：最小栈

原题链接：155. 最小栈 - 力扣（LeetCode）

class MinStack {
public:
    //因为成员属性都是自定义类型，编译器默认的构造函数符合需求
    //在这里所有的成员属性都会在初始化列表进行初始化，对于自定义类型会去调用它的默认构造函数
    MinStack() {}
    
    void push(int val) {
        //原栈无论什么情况都插入val
        _st.push(val);
        //辅助栈为空或者 val比辅助栈最小的数据(_min_st.top())还小时插入val
        if(_min_st.empty() || val <= _min_st.top())
            _min_st.push(val); 
    }
    
    void pop() {
        //当两个栈的栈顶数据一样时 _min_st才会pop
        if(_st.top() == _min_st.top())
        {
            _min_st.pop();
        }
        _st.pop();
    }
    
    int top() {
        return _st.top();
    }
    
    int getMin() {
        return _min_st.top();
    }
private:
    //原栈 所有数据都进入这里面    
    std::stack<int> _st;
    //辅助栈 最小数据才会进入这个栈
    std::stack<int> _min_st;
};

第二题：栈的压入、弹出序列

原题链接：栈的压入、弹出序列_牛客题霸_牛客网

//解题思路：  模拟入栈、出栈
bool IsPopOrder(vector<int>& pushV, vector<int>& popV) {
    // write code here
    std::stack<int> st;
    size_t push_nums = 0;
    size_t pop_nums = 0;
    while(push_nums < pushV.size())
    {
        while(pushV[push_nums] != popV[pop_nums])
        {
            st.push(pushV[push_nums++]);    
        }
        st.push(pushV[push_nums++]);
        while(!st.empty() && st.top() == popV[pop_nums])
        {
            st.pop();
            ++pop_nums;
        }
    }
    if(pop_nums == popV.size())
        return true;
    else
        return false;
}
//第二种写法
bool IsPopOrder(vector<int>& pushV, vector<int>& popV) {
    // write code here
    std::stack<int> st;
    size_t i = 0;
    for(auto e : pushV)
    {
        st.push(e);
        while(!st.empty() && st.top() == popV[i])
        {
            st.pop();
            ++i;
        }
    }
    return st.empty();
}

第三题：逆波兰表达式求值

原题链接：150. 逆波兰表达式求值 - 力扣（LeetCode）

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        //这个题是一个后缀表达式即：
        //a.操作数的顺序不变
        //b.操作符的优先级已经确定
        std::stack<int> st;
        for(auto e : tokens)
        {
            //1. 遇到操作符
            if(e == "+" 
            || e == "-"
            || e == "*"
            || e == "/")
            {
                //2. 取两个栈顶的数据
                //先得到右操作数
                int right = st.top();
                st.pop();
                //再得到左操作数
                int left = st.top();
                st.pop(); 
                //3. 进行运算，运算结果再入栈
                switch(e[0])
                {
                    case '+': st.push(left + right);break;
                    case '-': st.push(left - right);break;
                    case '*': st.push(left * right);break;
                    case '/': st.push(left / right);break;
                }
            }
            //4. 遇到操作数入栈
            else
            {
                st.push(std::stoi(e));
            }
        }
        //5. 返回栈顶数据
        return st.top();
    }
};

//补充： 如果是中缀表达式，需要先转化为后缀表达式，转化的过程实际上是更改操作符的优先级
//转化的步骤：
//1. 操作数输出(可以理解将数据放到另一个容器里)；
//2. 遇到操作符:
//a.如果栈为空或者比栈顶的操作符优先级高，入栈;
//b.如果比栈顶的操作符优先级低或者相等，出栈顶的操作符(和栈内的栈顶操作符遍历比较);
//c.如果遇到()提升()里面操作符的优先级;

2. queue的介绍和使用

// std::queue
template <class T, class Container = deque<T> > class queue;

2.1. 介绍

队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素；
队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素，元素从队尾入队列，从队头出队列；
底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作：
empty：检测队列是否为空；
size：返回队列中有效元素的个数；
front：返回队头元素的引用；
back：返回队尾元素的引用；
push_back：在队列尾部入队列；
pop_front：在队列头部出队列。
标准容器类 deque 和 list 满足了这些要求，默认情况下，如果没有为 queue 实例化指定容器类，则使用标准容器deque。

2.2. 使用

void Test2(void)
{
	std::queue<int> qu;
	qu.push(1);
	qu.push(2);
	qu.push(3);
	qu.push(4);
	qu.push(5);
	while (!qu.empty())
	{
		std::cout << qu.front() << " ";
		qu.pop();
	}
	std::cout << std::endl;
}

现象如下：

3. 栈和队列的实现

3.1. 栈的实现

以前在学习数据结构时，我们用C实现过数组栈和链式栈，而在C++中，我们没必要自己从写一个栈，而是选择对其他容器进行复用实现栈：

namespace Xq
{
	template<class T>
	class stack
	{
	public:
		void push(const T& val)
		{
			_con.push_back(val);
		}
		void pop()
		{
			_con.pop_back();
		}
		T& top()
		{
			return _con.back();
		}
		const T& top() const
		{
			return _con.back();
		}
		bool empty() const
		{
			return _con.empty();
		}
		size_t size() const
		{
			return _con.size();
		}
	private:
		std::vector<T> _con;
	};
}

可是上面的代码没有实现适配器，因为它里面的容器是固定的，因此我们需要：

namespace Xq
{
    //利用模板参数实现适配器，在这里跟标准库一样，默认适配器用deque<T>
    //template<class T,class container = std::vector<T>>
    //template<class T,class container = std::list<T>>
	template<class T,class container = std::deque<T>>
	class stack
	{
	public:
		void push(const T& val)
		{
			_con.push_back(val);
		}
		void pop()
		{
			_con.pop_back();
		}
		T& top()
		{
			return _con.back();
		}
		const T& top() const
		{
			return _con.back();
		}
		bool empty() const
		{
			return _con.empty();
		}
		size_t size() const
		{
			return _con.size();
		}
	private:
        // 我也不知道你是什么容器，让模板参数去推；
        // 只要你这个容器满足上面的接口即可
		container _con;
	};
}

测试 demo 如下：

void Test3(void)
{
	//Xq::stack<int,std::vector<int>> st;
	Xq::stack<int, std::list<int>> st;
	st.push(1);
	st.push(2);
	st.push(3);
	st.push(4);
	st.push(5);
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
	cout << endl;
}

不论用 vector 或者 list 结果是一样的，现象如下：

3.2. 队列的实现

队列的实现和栈没有太大差别，只不过对于数据的访问需要符合FIFO。

namespace Xq
{
	//template<class T,class container = std::list<T>>
	template<class T, class container = std::deque<T>>
	class queue
	{
	public:
		void push(const T& val)
		{
			_con.push_back(val);
		}
		void pop()
		{
			_con.pop_front();
		}
		T& front()
		{
			return _con.front();
		}
		const T& front() const
		{
			return _con.front();
		}
		T& back()
		{
			return _con.back();
		}
		const T& back() const
		{
			return _con.back();
		}
		bool empty() const
		{
			return _con.empty();
		}
		size_t size() const
		{
			return _con.size();
		}
	private:
		container _con;
	};
}

测试代码如下：

void Test4(void)
{
	Xq::queue<int> qu;
    //Xq::queue<int,std::list<int>> qu;
	qu.push(1);
	qu.push(2);
	qu.push(3);
	qu.push(4);
	while (!qu.empty())
	{
		cout << qu.front() << " ";
		qu.pop();
	}
	cout << endl;
}

不论底层容器是deque<T>还是list<T>，结果都是一样的，现象如下：

但是在这里是不能用vector<T>的，因为vector<T>是没有pop_front()的。

4. priority_queue的介绍和使用

// std::priority_queue
template <class T, class Container = vector<T>,
  class Compare = less<typename Container::value_type> >class priority_queue;

4.1. 介绍

优先级队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素是它所包含的元素中最大的(默认情况下为大堆)；
此上下文类似于堆，在堆中可以随时插入元素，并且只能检索堆顶元素(优先队列中位于顶部的元素)；
优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，priority_queue 提供一组特定的成员函数来访问其元素，元素从特定容器的 "尾部" 弹出，其称为优先级队列的顶部；
底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类，容器应该可以通过随机访问迭代器访问，并支持以下操作：
empty()：检测容器是否为空；
size()：返回容器中有效元素个数；
front()：返回容器中第一个元素的引用；
push_back()：在容器尾部插入元素；
pop_back()：删除容器尾部元素。
标准容器类 vector 和 deque 满足这些需求。默认情况下，如果没有为特定的priority_queue 类实例化指定容器类，则使用vector；
需要支持随机访问迭代器，以便始终在内部保持堆结构，容器适配器通过在需要时自动调用算法函数 make_heap、push_heap和pop_heap来自动完成此操作。

优先级队列默认使用 vector 作为其底层存储数据的容器，在 vector 上又使用了堆算法将vector 中元素构造成堆的结构，因此 priority_queue 就是堆，所有需要用到堆的场景，都可以考虑使用 priority_queue。注意：默认情况下priority_queue是大堆。

4.2. 使用

priority_queue，可以支持无参构造，也可以支持迭代器区间构造，如下：

void Test7(void)
{
	// 可以支持无参构造
	std::priority_queue<int> pq1;

	// 也可以支持迭代器区间构造
	std::vector<int> v{ 5, 7, 2, 4, 8, 1, 10, 3 };
	std::priority_queue<int> pq2(v.begin(), v.end());
}

priority_queue 默认情况下是大堆，验证如下：

void Test8(void)
{
	std::priority_queue<int> pq;
	pq.push(2);
	pq.push(1);
	pq.push(4);
	pq.push(3);
	pq.push(6);
	pq.push(5);
	while (!pq.empty())
	{
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;
}

结果如下所示：

因为 priority_queue 默认情况下是大堆，堆顶的数据优先级高，所以先遍历堆顶数据，那如果我想用小堆呢？

void Test9(void)
{
	std::vector<int> v{ 6, 5, 4, 3, 2, 1, 0 };
	// 如果我们不想默认为大堆，可以显式初始化为小堆，需要增加第三个模板参数(在这里是一个仿函数)
	// greater 在 functional 这个头文件里
	std::priority_queue<int, std::vector<int>, std::greater<int>> pq{ v.begin(), v.end()};
	while (!pq.empty())
	{
		std::cout << pq.top() << " ";
		pq.pop();
	}
	std::cout << std::endl;
}

现象如下：

4.3. 练习题

原题链接：215. 数组中的第K个最大元素 - 力扣（LeetCode）

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        std::priority_queue<int> pq;
        //建堆： O(N)
        for(auto e : nums)
            pq.push(e);
        //pop掉前k-1个elements O(logN*k)   
        while(--k)
            pq.pop();
        return pq.top();
    }
};

//思考: 如果这里的数据很大，内存存不下，那么我们需要建k个数据的小堆

4.4. 模拟实现

4.4.1. 初步实现

namespace Xq
{
	template<class T,class container = std::vector<int>>
	class priority_queue
	{
	public:

		priority_queue(){}

		template<class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				_con.push_back(*first);
				++first;
			}

			for (int end = (_con.size() - 1 - 1) / 2; end >= 0; --end)
			{
				adjust_down(end);
			}
		}
        //向上调整算法
		void adjust_up(size_t child)
		{
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				if (_con[child] > _con[parent])
				{
					std::swap(_con[child], _con[parent]);
					child = parent;
					if (child != 0)
						parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		void push(const T& val)
		{
			_con.push_back(val);
			//在这里我们默认为大堆
			adjust_up(_con.size() - 1);
		}
        //向下调整算法
		void adjust_down(size_t parent)
		{
			size_t child = parent * 2 + 1;
			while (child < _con.size())
			{
				if (child + 1 < _con.size() && _con[child] < _con[child + 1])
				{
					++child;
				}
				if (_con[parent] < _con[child])
				{
					std::swap(_con[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}

		void pop()
		{
			if (empty())
				return;
			std::swap(_con.front(), _con.back());
			_con.pop_back();
			adjust_down(0);
		}

		const T& top() const
		{
			return _con.front();
		}

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

		size_t size() const
		{
			return _con.size();
		}
	private:
		container _con;
	};

}

但是现在存在一个问题，我们上面的代码是写死的，它只能建大堆，因此我们需要引入一个东西：仿函数，什么叫仿函数呢？

4.4.2. 仿函数的理解

仿函数，顾名思义，像函数的一个东西。

具体来说，仿函数并不是一个函数，而是一个类，这个类有一个特征：重载了函数调用运算符即operator()，使得通过这个类实例化的对象可以像函数一样使用，故称之为仿函数。

比如下面这个 demo ：

namespace Tmp
{
	template<class T>
	class less
	{
	public:
        //less这个类重载了()这个运算符---仿函数
		bool operator()(const T& left, const T& right) const
		{
			return left < right;
		}
	};
}
void Test12(void)
{
	Tmp::less<int> tmp;
    // tmp.operator()(10,20);
	cout << tmp(10, 20) << endl;
}

单独看 cout << tmp(10, 20) << endl；

这句代码我们很可能认为 tmp 是一个函数名，可实际上这是一个类实例化的对象，这个对象可以像函数一样去使用(对象调用了operator())，因此，我们认为，可以实例化这种对象的类我们称之为仿函数。

4.4.3. 完整实现

通过仿函数这个模板参数实现泛型化：

namespace Xq
{
	//compare进行比较的仿函数，如果是less<int>那么对应为大堆，如果是greater<int>那么对应为小堆
	template<class T,class container = std::vector<int>, class compare = std::less<int>>
	class priority_queue
	{
	public:
		priority_queue(){}

		template<class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				_con.push_back(*first);
				++first;
			}

			for (int end = (_con.size() - 1 - 1) / 2; end >= 0; --end)
			{
				adjust_down(end);
			}
		}

		void adjust_up(size_t child)
		{

			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				//if (_con[child] > _con[parent])
				//if (_con[parent] < _con[child])
				if (_com(_con[parent], _con[child]))   //默认情况下调用了less::operator()
				{
					std::swap(_con[child], _con[parent]);
					child = parent;
					if (child != 0)
						parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		void push(const T& val)
		{
			_con.push_back(val);
			adjust_up(_con.size() - 1);
		}

		void adjust_down(size_t parent)
		{
			size_t child = parent * 2 + 1;
			while (child < _con.size())
			{
				//if (child + 1 < _con.size() && _con[child + 1] > _con[child])
				//if (child + 1 < _con.size() && _con[child] < _con[child + 1])
				if (child + 1 < _con.size() && _com(_con[child],_con[child + 1]))
				{
					++child;
				}
				//if (_con[child] > _con[parent])
				//if (_con[parent] < _con[child])
				if (_com(_con[parent], _con[child])) 
				{
					std::swap(_con[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}

		void pop()
		{
			if (empty())
				return;
			std::swap(_con.front(), _con.back());
			_con.pop_back();
			adjust_down(0);
		}

		const T& top() const
		{
			return _con.front();
		}

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

		size_t size() const
		{
			return _con.size();
		}
	private:
		container _con;
		compare _com;
	};
}

测试 demo 如下：

void Test13(void)
{
	Xq::priority_queue<int,std::vector<int>,std::less<int>> pq;
    //Xq::priority_queue<int,std::vector<int>,std::greater<int>> pq;
	pq.push(2);
	pq.push(1);
	pq.push(4);
	pq.push(3);
	pq.push(6);
	pq.push(5);
	while (!pq.empty())
	{
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;
}

结果：
如果第三个模板参数是std::less<int> 那么就是大堆，结果为：
6 5 4 3 2 1

如果第三个模板参数是std::greater<int> 那么就是小堆，结果为：

1 2 3 4 5 6

通过模板参数达到了泛型。

我们以前学习过标准库的 std::sort，以前不知道第三个参数是什么，现在我们就知道了：

template <class RandomAccessIterator, class Compare>
  void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

事实上，这里的 compapre 是一个函数模板参数，因此，在使用时，需要传递一个仿函数对象。

测试 demo 如下：

void Test14(void)
{
	std::vector<int> v{ 1, 6, 4, 2, 3, 7, 5, 9, 10, 8 };
	for (auto e : v)
		std::cout << e << " ";
	std::cout << std::endl;
	// 因为 sort 的模板参数是函数模板参数, 需要传递对象, 在这里我们传递的是匿名对象
	std::sort(v.begin(), v.end(), std::less<int>());
	for (auto e : v)
		std::cout << e << " ";
	std::cout << std::endl;
	std::sort(v.begin(), v.end(), std::greater<int>());
	for (auto e : v)
		std::cout << e << " ";
	std::cout << std::endl;
}

现象如下：

我们可以通过第三个模板参数来确定数据的顺序(升序/降序)；

5. 容器适配器

5.1. 容器适配器是什么？

适配器是一种设计模式，用于将一个接口转换为另一个客户端期望的接口。它允许不兼容的接口能够一起工作，将一个类的接口转换为客户端所期望的接口，从而使得不同的类能够协作工作。

容器适配器是一种特殊形式的适配器，用于将一个容器类的接口转换为另一个容器类的接口。它允许不同类型的容器在使用上彼此兼容，从而可以在不改变原有代码的情况下进行容器之间的转换和使用。常见的容器适配器包括栈（stack）、队列（queue）、优先队列（priority_queue）等。这些适配器类会利用底层容器类（如vector、list、deque等）来实现其功能，从而实现了不同容器类之间的适配。

5.2. STL标准库中的stack和queue

虽然 stack 和 queue 中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为 stack 和 queue 只是对其他容器的接口进行了封装，STL中stack和queue默认使用的是deque，比如：

//std::stack
template <class T, class Container = deque<T> > class stack;

//std::queue
template <class T, class Container = deque<T> > class stack;

5.3. 了解deque

// std::deque
template < class T, class Alloc = allocator<T> > class deque;

我们可以看一下STL标准库中的deque的接口：

deque 支持随机访问，如下：

它也支持任意位置插入：

可以看到， deque 既支持随机访问，有支持任意位置的插入，看起来非常好，但是实际运用不多，为什么这么说呢？

deque (双端队列) ：是一种双开口的 "连续" 空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。

但是 deque 并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组，其底层结构如下图所示：

如何验证 deque 的 operator[] 当大量访问数据时，会影响效率(与vector相比)：

void Test5(void)
{
	srand((size_t)time(nullptr));
	const int N = 10000000;
	std::vector<int> v;
	std::deque<int> dq;
	v.reserve(N);
	for (size_t i = 0; i < N; ++i)
	{
        ine tmp = rand();
		v.push_back(tmp);
		dq.push_back(tmp);
	}
	int begin1 = clock();
	std::sort(v.begin(), v.end());
	int end1 = clock();

	int begin2 = clock();
	std::sort(dq.begin(), dq.end());
	int end2 = clock();
	cout << "vector sort = " << end1 - begin1 << endl;
	cout << "deque sort = " << end2 - begin2 << endl;
}

结果如下 (在release版下) ：

双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其 "整体连续" 以及随机访问的假象，落在了deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图所示：

中控器存储的是每一个 buffer 的地址；
cur：当前数据的地址；
first：buffer缓冲区的起始位置；
last： buffer缓冲区的终止位置 ( 最后一个有效元素的下一个位置 )；
node：反向指向中控位置，以便于找到下一个buffer。

那 deque 是如何借助其迭代器维护其假想连续的结构呢？

我们如何从 buffer1->buffer2呢？

如果cur != last，那么++cur；

如果cur == last了，我们需要切换下一个buffer，即++node，并重置 first 和 last，让 cur = first，继续遍历。

对于deque而言，头尾的插入删除非常高效，相比 vector 和 list 而言，更适合去做 stack 和queue 的默认适配器；

如果中间需要大量删除插入数据，更好的方案还是 list；

如果随机访问更多，vector更有优势。

5.4. deque 的总结

deque 的总结：

与 vector 比较，deque 的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率是比vector高的；
与 list 比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。

deque 的缺陷：

但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑 vector 和 list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为 stack 和 queue 的底层数据结构。

为什么STL选择 deque 作为 stack 和 queue 的底层默认容器：
stack 是一种后进先出 (LIFO) 的特殊线性数据结构，因此只要具有 push_back 和 pop_back 操作的线性结构，都可以作为 stack 的底层容器，比如 vector 和 list 都可以；
queue 是先进先出 ( FIFO) 的特殊线性数据结构，只要具有 push_back 和 pop_front 操作的线性结构，都可以作为 queue 的底层容器，比如list。

但是 STL 中对 stack 和 queue 默认选择 deque 作为其底层容器，主要是因为：

stack 和 queue 不需要遍历 (因此stack和queue没有迭代器)，只需要在固定的一端或者两端进行操作；
stack 中元素增长时，deque 比 vector 的效率高(扩容时不需要搬移大量数据)；
queue 中的元素增长时，deque 不仅效率高，而且内存使用率高 (deque适合头尾部插入数据)；
因此 stack 和 queue 这两种数据结构结合了deque的优点，而完美的避开了其缺陷。

---徐乾---

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++栈和队列

1.1. 介绍1. stack是一种容器适配器，专门用在具有后进先出(LIFO)操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。2. stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶被压入和弹出。3. stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：empty：判空操作back：获取尾部元素操作。
复制链接

扫一扫