【C++】容器篇（三）—— stack的基本介绍及其模拟实现网站首页 技术杂谈

1. stack：stack是一种LIFO（Last-In-First-Out）容器，只允许在容器的一端插入和删除元素。通过stack，我们可以快速、轻松地实现如撤销、反转等功能。
2. queue：queue是一种FIFO（First-In-First-Out）容器，只允许在容器的一端插入元素，在容器的另一端删除元素。通过queue，我们可以快速、轻松地实现如模拟消息队列等功能。
3. priority_queue：priority_queue是一个优先级队列，它存储一组具有优先级的值，并按照优先级从高到低排序。通过priority_queue，我们可以快速、轻松地实现如任务调度等功能。

总结来说，容器适配器是为了方便使用STL中的已有容器类而设计的。通过简洁的接口，容器适配器提供了更高层次的容器类，简化了某些数据结构的实现。

（二）基本使用

接下来，我先通过具体的使用来带大家先感受一下用法是如何的。

具体如下：

void test_1()
{
	stack<int> str;

	// 在栈顶添加元素
	str.push(1);
	str.push(2);
	str.push(3);
	str.push(4);
	str.push(5);

	//栈顶元素
	if (!str.empty())
	{
		cout << str.top() << " " << str.size() << endl;;
	}


	// 从栈顶弹出元素
	str.pop();

	// 获取栈顶元素
	cout << str.top() << endl;

	// 检查栈是否为空
	if (str.empty())
	{
		cout << "Stack is empty" << endl;
	}
	else
	{
		cout << "Stack is not empty" << endl;
	}

	// 获取栈的大小
	cout << "Stack size is " << str.size() << endl;
}

结果如下：

解释说明：

1、在上述代码中，我们先往栈里面插入了5个元素；
2、紧接着，我们就验证了开头说的说的是否符合后进先出的规则，最终结果也成功的表明了相应的观点；
3、接下来，经过pop 操作之后，在打印栈顶元素，我们可以发现此时的结果为4，也符合相应的预期；
4、接下来，就是对其的栈是否为空的基本判断，以及stack大小的计算操作。

（三）stack模拟实现

stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：

empty：判空操作
back：获取尾部元素操作
push_back：尾部插入元素操作
pop_back：尾部删除元素操作

? 标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器，默认情况下使用deque。

1、stack的使用

2、模拟实现

? 从栈的接口中可以看出，栈实际是一种特殊的vector，因此使用vector完全可以模拟实现stack。

1️⃣push()

void push(const T& x)
{
	_vv.push_back(x);
}

2️⃣pop()

void pop()
{
	if (!_vv.empty())
	{
		_vv.pop_back();
	}
}

3️⃣top()

const T& top()
{
	return _vv.back();
}

4️⃣empty()

bool empty()
{
	return _vv.empty();
}

5️⃣size()

size_t size()
{
	return _vv.size();
}

整体代码如下：

#pragma once
#include<vector>
#include<list>
namespace zp
{
	template<class T, class Container>
	class stack
	{
	public:
		void push(const T& x)
		{
			_vv.push_back(x);
		}


		void pop()
		{
			if (!_vv.empty())
			{
				_vv.pop_back();
			}
		}

		const T& top()
		{
			return _vv.back();
		}


		bool empty()
		{
			return _vv.empty();
		}


		size_t size()
		{
			return _vv.size();
		}

	private:
		Container _vv;
	};
}

当我们要实现数组栈、链式栈，我们还需要自己实现吗，在这里就可以使用适配器模式，使用已有的容器对其进行封装操作；
但是当我们像 vector<T> _vv 或 list<int> _vv 这样定义时其实还没有真正的实现适配。就像平常生活中的电源适配器一样的，它可以把220v的转化为 10v 或者 20v ，因此在定义模板增加了一个【Container】的模板参数，即 ⚔️ template<class T, class Container> ⚔️ ，当然当我们想实现数组栈还可以这样 ⚔️ template<class T, class Container = vector<T>> ⚔️

当我们想使用时直接用即可：

stack<int, vector<int>> str;
stack<int, list<int>> str;
stack<int> str;

（四）题目讲解

1、逆波兰表达式求值

链接如下：150. 逆波兰表达式求值

题目如下：

解题思路：

首先，在正式的解题之前，我们先认识一下什么叫做逆波兰表达式。

? 逆波兰表达式是一种计算表达式的方式，也称为后缀表达式

它的特点是把操作符写在操作数的后面，从左到右扫描表达式，遇到操作数就把它压入栈中，遇到操作符就从栈中取出所需的操作数进行运算，运算结果再存入栈中；
最后栈中只剩下一个数，即该表达式的计算结果。

首先，我先举例分析一波例如，表达式tokens = ["2","1","+","3","*"] 的运算过程如下：

扫描到数字2，将其压入栈中。
扫描到数字1，将其压入栈中。
扫描到符号"+"，从栈中弹出操作数4和3，计算2+1=3，将结果3压入栈中。
继续扫描，将数字3压入栈中。
扫描到符号" * "，从栈中弹出操作数3和3，计算3*3=9，将结果9压入栈中。
表达式扫描完毕，栈中剩下唯一数字9，即该表达式的计算结果。

因此以下是逆波兰表达式的解题思路：

定义一个栈s，用于存放操作数和中间运算结果。
从左到右扫描表达式，遇到数字就把它压入栈中。
遇到操作符时，从栈中弹出两个操作数进行运算。运算结果再压入栈中。
重复步骤2和3，直到表达式扫描完毕。
栈中剩下的唯一数字就是该表达式的计算结果。

代码展示：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> s;
        for (auto e : tokens) {
            if (e == "+" || e == "-" || e == "*" || e == "/") {
                int b = s.top();
                s.pop();
                int tmp = s.top();
                s.pop();
                if (e == "+") 
                    s.push(tmp + b);
                else if (e == "-") 
                    s.push(tmp - b);
                else if (e == "*") 
                    s.push(tmp * b);
                else if (e == "/") 
                    s.push(tmp / b);
            } 
            else {
                s.push(stoi(e));
            }
        }
    return s.top();
    }
};