文章目录
- 一、stack的使用
- 1.stack的介绍
- 2.stack的使用
- 二、queue的使用
- 1.queue的护额晒
- 2.queue的使用
- 三、stack和queue相关算法题
- 1.最小栈
- 2.栈的压入、弹出序列
- 3.逆波兰表达式
- 4.两个栈实现一个队列
- 5.用两个队列实现栈
- 6.二叉树的层序遍历
- 1.双队列
- 2.用一个变量levelSize去控制
- 7.二叉树的层序遍历Ⅱ
一、stack的使用
1.stack的介绍
栈是一种容器适配器，专门设计用于在 LIFO 上下文中操作(后进先出)，其中元素只从容器的一端插入和提取。
栈被实现为容器适配器，这些类使用特定容器类的封装对象作为其底层容器，提供一组特定的成员函数来访问其元素。 元素从特定容器的“后端”被推入/弹出，这被称为栈的顶部。
底层容器可以是任何标准的容器类模板，也可以是其他一些专门设计的容器类。容器应该支持以下操作：empty、size、back、push_back、pop_front
标准容器类 vector、deque 和 list 满足这些要求。默认情况下，如果没有为特定的堆栈类实例化指定容器类，则使用标准容器 deque。
这里我们需要知道的是，Container适配器就是一个现有的容器进行的一个转换
也就是说，适配器的本质就是一种复用
2.stack的使用
我们先看stack的接口有哪些
如上所示，这里其实我们一看就已经猜出了七七八八了。因为与前面是string、vector、list是十分相似的。只要结合它的先进先出的特性，我们就知道每个函数都是什么意思了。
对于stack的使用是非常简单的
void test_stack()
{
stack<int> st1;
st1.push(1);
st1.push(2);
st1.push(3);
st1.push(4);
while (!st1.empty())
{
cout << st1.top() << " ";
st1.pop();
}
cout << endl;
}
二、queue的使用
1.queue的护额晒
队列是一种容器适配器，专门设计用于在FIFO上下文中操作(先进先出)，其中将元素插入容器的一端并从另一端提取。
队列是作为容器适配器实现的，容器适配器是使用特定容器类的封装对象作为其底层容器的类，提供一组特定的成员函数来访问其元素。元素被推入特定容器的“后面”，并从其“前面”弹出。
底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:empty、size、front、back、push_back、pop_back。
标准容器类deque和list满足这些要求。默认情况下，如果没有为特定队列类实例化指定容器类，则使用标准容器队列。
2.queue的使用
同样的，我们先来看queue的接口有哪些
在这些接口中，和stack是类似的，只要我们知道了queue的特性是先进先出。我们就能很轻松的推测出每个接口的意思
对于queue的使用是很简单的
void test_queue()
{
queue<int> q;
q.push(1);
q.push(2);
q.push(3);
q.push(4);
while (!q.empty())
{
cout << q.front() << " ";
q.pop();
}
cout << endl;
}
三、stack和queue相关算法题
1.最小栈
题目链接：最小栈
题目解析：在这道题中，我们为了模拟这种情况，我们可以在成员变量中定义两个栈，一个栈作为正常的出入数据使用，一个栈用来存储最小值。
首先是构造函数，由于我们的成员变量都是自定义类型，所以会自动调用他们的默认构造函数，即他们也会走初始化列表，所以默认构造函数我们是可以直接不用管的。甚至于我们可以直接删掉题目给的构造函数，因为我们不写，编译器自己生成一个。
其次我们的大逻辑是这样的，当我们最小栈为空的时候，我们的最小栈是需要入一个数据的，当我们将要插入的元素是小于等于最小栈要插入的元素的时候，我们会将这个元素给入最小栈
当我们pop的时候，我们也是同理的，如果我们要删除的数据等于最小栈的栈顶元素，那么就也要删除最小栈的栈顶元素。
class MinStack {
public:
MinStack()
{}
void push(int val) {
st.push(val);
if(min.empty()||(val<=min.top()))
{
min.push(val);
}
}
void pop() {
int val=st.top();
st.pop();
if(val==min.top())
{
min.pop();
}
}
int top() {
return st.top();
}
int getMin() {
return min.top();
}
private:
stack<int> st;
stack<int> min;
};
/**
* Your MinStack object will be instantiated and called as such:
* MinStack* obj = new MinStack();
* obj->push(val);
* obj->pop();
* int param_3 = obj->top();
* int param_4 = obj->getMin();
*/
2.栈的压入、弹出序列
题目链接：栈的压入弹出序列
题目解析：我们可以使用一个栈来模拟它的入栈出栈逻辑，只要顺着它的思路最终我们的这个栈是空栈的话，那么就说明是匹配的，否则不匹配
class Solution {
public:
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param pushV int整型vector
* @param popV int整型vector
* @return bool布尔型
*/
bool IsPopOrder(vector<int>& pushV, vector<int>& popV) {
// write code here
stack<int> st;
int n=pushV.size();
int j=0;
for(int i=0;i<n;i++)
{
st.push(pushV[i]);
while(!st.empty() && st.top()==popV[j])
{
st.pop();
j++;
}
}
return st.empty();
}
};
3.逆波兰表达式
题目链接：逆波兰表达式
再谈这道题之前，我们应该先知道什么是逆波兰表达式，我们正常的都是中缀表达式，即3+2*5这种的，都被称之为中缀表达式。
而中缀表达式在计算机中是很难进行运算的。我们需要先将其转换为后缀表达式，前文所说的中缀表达式转化为后缀表达式后应该为3 2 5 * +。后缀表达式的特点就是操作数的顺序不变，而操作符的顺序按照优先级进行了重排。
我们先来看一下后缀运算符是如何进行运算的：
- 操作数入栈
- 如果是操作符，取出栈顶的两个元素进行计算，计算结果放入栈中
那么如何使得中缀转为后缀呢？
- 操作数输出（即将操作数放到一个容器中）
- 操作符入栈 ： ①栈为空，当前操作符比栈顶的优先级高，继续入栈 ②栈不为空，且当前操作符比栈顶的优先级低或者相等，则输出栈顶操作符（因为运算符的优先级只与它相邻的操作符有关，是相对的，如果后面出现了一个更高的操作符，我们无法确定后面是否还有更高的操作符，反而是如果有一个相对较低的操作符，那么前两个肯定是可以进行运算的）
- 表达式结束后，依次出栈顶的操作符
- 注意，有可能会在转换的中间出现连续出操作符的情况，即栈里面已经存储了好几个运算符了，下面的一个运算符要比好几个都要低，就要连续出好几个运算符
比如说2+4-1*3，这个中缀表达式，按照上面的规则可以化为
上面都是正常情况的下的处理，但是还有时候会出现括号的影响。
这里可以考虑加上一个特殊标记，当我们这个标记生效时，就代表进入括号内了。或者在这里走一个递归也是可以的。递归的方法就是在遇到括号的时候，我们将括号里面的运算符就需要放入一个新的栈中了。相当于我们只需要让括号返回一个结果就可以了。但是数据还是输出在原来的顺序表中的
我们在回过头来看这道题，我们有了上面的分析，就很容易写出下面代码了。
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> st;
for(auto& str : tokens)
{
if(str=="+"||str=="-"||str=="*"||str=="/")
{
int right=st.top();
st.pop();
int left=st.top();
st.pop();
switch(str[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;
}
}
else
{
st.push(stoi(str));
}
}
return st.top();
}
};
4.两个栈实现一个队列
题目链接：两个栈实现一个队列
对于这个题，我们在之前也已经做过一次分析了，只不过上一次是用C语言手撕了一个栈来实现了。而现在呢，我们有C++的库了，因此我们就可以直接使用C++的库来完成这件事。
class MyQueue {
public:
MyQueue() {}
void push(int x) {
_push.push(x);
}
int pop() {
if(_pop.empty())
{
while(!_push.empty())
{
int val=_push.top();
_push.pop();
_pop.push(val);
}
}
int val=_pop.top();
_pop.pop();
return val;
}
int peek() {
if(_pop.empty())
{
while(!_push.empty())
{
int val=_push.top();
_push.pop();
_pop.push(val);
}
}
return _pop.top();
}
bool empty() {
return (_push.empty()&&_pop.empty());
}
private:
stack<int> _push;
stack<int> _pop;
};
/**
* Your MyQueue object will be instantiated and called as such:
* MyQueue* obj = new MyQueue();
* obj->push(x);
* int param_2 = obj->pop();
* int param_3 = obj->peek();
* bool param_4 = obj->empty();
*/
5.用两个队列实现栈
题目链接：用两个队列实现栈
这道题与上面的题类似，我们也是曾经使用C语言做过，不过由于C语言没有轮子，就需要我们自己造轮子，有了很多的麻烦。
class MyStack {
public:
MyStack() {}
void push(int x) {
if(q1.empty())
{
q2.push(x);
}
else
{
q1.push(x);
}
}
int pop() {
if(q1.empty())
{
while(q2.size()>1)
{
int val=q2.front();
q2.pop();
q1.push(val);
}
int val=q2.front();
q2.pop();
return val;
}
else
{
while(q1.size()>1)
{
int val=q1.front();
q1.pop();
q2.push(val);
}
int val=q1.front();
q1.pop();
return val;
}
}
int top() {
if(q1.empty())
{
return q2.back();
}
else
{
return q1.back();
}
}
bool empty() {
return (q1.empty()&&q2.empty());
}
private:
queue<int> q1;
queue<int> q2;
};
/**
* Your MyStack object will be instantiated and called as such:
* MyStack* obj = new MyStack();
* obj->push(x);
* int param_2 = obj->pop();
* int param_3 = obj->top();
* bool param_4 = obj->empty();
*/
6.二叉树的层序遍历
题目链接：二叉树的层序遍历
对于这道题，如果不是用C++来完成的话，用C去完成的话是非常难的。不仅我们要确保我们造的轮子是正确的，而且还有很多细节需要进行处理，但我们如果使用C++的话可以极大的简化很多操作
1.双队列
我们可以使用两个队列去完成这件事，一个队列用来存储结点指针，一个队列用来存储该节点处于哪个层。这样我们就可以知道哪个结点是那个层的了，自然我们就很容易的得知层序遍历了。
2.用一个变量levelSize去控制
这种思路是比较奇妙的，我们使用一个变量来确定当前该层有多少个结点，用一个队列来存储结点，然后就是层序遍历的基本套路，每出一个结点，带来两个孩子。将每一层的数据存储在一个vector中，然后一层结束后将这一层的vector插入到vector<vector<int>>中。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
queue<TreeNode*> q;
int levelSize=0;
if(root)
{
q.push(root);
levelSize=1;
}
vector<vector<int>> vv;
while(!q.empty())
{
vector<int> v;
for(int i=0;i<levelSize;i++)
{
TreeNode* front=q.front();
q.pop();
v.push_back(front->val);
if(front->left)
{
q.push(front->left);
}
if(front->right)
{
q.push(front->right);
}
}
vv.push_back(v);
levelSize=q.size();
}
return vv;
}
};
7.二叉树的层序遍历Ⅱ
题目链接:二叉树的层序遍历Ⅱ
对于这道题目，我们可以注意到他是让倒着遍历的。和前一道题基本是一样的，只是改变了vv的顺序。即相当于将vv给逆序。那么这道题就太简单了，直接将前面这道题给拷贝过来，然后调用库里面的reverse即可
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<vector<int>> levelOrderBottom(TreeNode* root) {
queue<TreeNode*> q;
int levelSize=0;
if(root)
{
q.push(root);
levelSize=1;
}
vector<vector<int>> vv;
while(!q.empty())
{
vector<int> v;
for(int i=0;i<levelSize;i++)
{
TreeNode* front=q.front();
q.pop();
v.push_back(front->val);
if(front->left)
{
q.push(front->left);
}
if(front->right)
{
q.push(front->right);
}
}
vv.push_back(v);
levelSize=q.size();
}
reverse(vv.begin(),vv.end());
return vv;
}
};
好了，本期内容就到这里了
如果对你有帮助的话，不要忘记点赞加收藏哦！！！
