在C++中，stack 是一种标准模板库（STL）容器适配器，它提供了后进先出（LIFO, Last In First Out）的数据结构。stack 适配器基于其他底层容器（如 deque 或 vector）来实现，但只提供有限的接口来访问这些容器中的元素。
基本用法
包含头文件
要使用 stack，首先需要包含相应的头文件：
#include <stack> |
声明一个栈
可以声明一个栈来存储特定类型的元素，例如整数：
std::stack<int> myStack; |
默认情况下，stack 使用 std::deque 作为其底层容器。如果需要指定其他底层容器，可以使用模板参数：
std::stack<int, std::vector<int>> myStackWithVector; |
常用成员函数
push(const T& value)：将元素压入栈顶。pop()：移除栈顶元素。top()：返回栈顶元素的引用，但不移除它。empty()：检查栈是否为空，返回布尔值。size()：返回栈中元素的个数。
示例代码
以下是一个简单的示例，演示如何使用 stack：
#include <iostream> | |
#include <stack> | |
int main() { | |
std::stack<int> myStack; | |
// 压入元素 | |
myStack.push(10); | |
myStack.push(20); | |
myStack.push(30); | |
// 查看栈顶元素 | |
std::cout << "Top element: " << myStack.top() << std::endl; // 输出 30 | |
// 弹出栈顶元素 | |
myStack.pop(); | |
std::cout << "Top element after pop: " << myStack.top() << std::endl; // 输出 20 | |
// 检查栈是否为空 | |
if (!myStack.empty()) { | |
std::cout << "Stack is not empty." << std::endl; | |
} | |
// 获取栈的大小 | |
std::cout << "Stack size: " << myStack.size() << std::endl; // 输出 2 | |
return 0; | |
} |
注意事项
- 访问元素：
stack只允许访问栈顶元素，无法直接访问栈中的其他元素。 - 性能：
stack的性能通常取决于其底层容器的性能。默认情况下，使用deque作为底层容器时，push和pop操作的时间复杂度都是 O(1)。 - 异常安全性：
stack的成员函数在异常发生时能够保持容器的一致性。
总结
stack 是一种非常有用的数据结构，适用于需要后进先出访问模式的场景。通过 C++ STL 提供的 stack 适配器，可以方便地实现这种数据结构，并享受其高效的性能和异常安全性。
示例代码
1.删除字符串中的所有相邻重复项
给出由小写字母组成的字符串 s，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
在 s 上反复执行重复项删除操作，直到无法继续删除。
在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。
示例：
输入："abbaca" 输出："ca" 解释： 例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。
解法(栈)
算法思路:
本题极像我们玩过的「开心消消乐」游戏，当前元素是否被消除，需要知道上一个元素的信息，因此可以用「栈」来保存信息。
但是，如果使用 stack 来保存的话，最后还需要把结果从栈中取出来。不如直接用「数组模拟一个栈」结构:在数组的尾部「尾插尾删」，实现栈的「进栈」和「出栈」。那么最后数组存留的内容就是最后的结果。
重点：能不能想到用栈来解决问题
class Solution {
public:string removeDuplicates(string s){string str;//搞一个数组，模拟栈结构即可int i = 0;while (i < s.size()){if (str.empty()){str += s[i++];continue;}if (s[i] == str.back()){str.pop_back();//出栈i++;}elsestr += s[i++];//进栈}return str;}
};2.比较含退格的字符串
给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。
注意：如果对空文本输入退格字符，文本继续为空。
示例 1：
输入：s = "ab#c", t = "ad#c" 输出：true 解释：s 和 t 都会变成 "ac"。
示例 2：
输入：s = "ab##", t = "c#d#" 输出：true 解释：s 和 t 都会变成 ""。
示例 3：
输入：s = "a#c", t = "b" 输出：false 解释：s 会变成 "c"，但 t 仍然是 "b"。
解法(用数组模拟栈)
算法思路:
由于退格的时候需要知道「前面元素」的信息，而且退格也符合后进先出」的特性。因此我们可以使用「栈」结构来模拟退格的过程。
- 当遇到非 #字符的时候，直接进栈;
- 当遇到 #的时候，栈顶元素出栈。
为了方便统计结果，我们使用「数组」来模拟实现栈结构。
class Solution {
public:bool backspaceCompare(string s, string t) {string str;string ttr;for(auto x:s){if(x=='#'){if(str.size())str.pop_back();elsecontinue;}elsestr+=x;}for(auto x:t){if(x=='#'){if(ttr.size())ttr.pop_back();elsecontinue;}elsettr+=x;}return str==ttr;}
};3.基本计算器 II
给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。
整数除法仅保留整数部分。
你可以假设给定的表达式总是有效的。所有中间结果将在 [-231, 231 - 1] 的范围内。
注意：不允许使用任何将字符串作为数学表达式计算的内置函数，比如 eval() 。
示例 1：
输入：s = "3+2*2" 输出：7
示例 2：
输入：s = " 3/2 " 输出：1
示例 3：
输入：s = " 3+5 / 2 " 输出：5
解法(栈)
算法思路:
由于表达式里面没有括号，因此我们只用处理「加减乘除」混合运算即可。根据四则运算的顺序，我们可以先计算乘除法，然后再计算加减法。由此，我们可以得出下面的结论:
- 当一个数前面是 '+' 号的时候，这一个数是否会被立即计算是「不确定人的，因此我们可以先压入栈中;
- 当一个数前面是 '-' 号的时候，这一个数是否被立即计算也是「不确定」的，但是这个数已经和前面 的-号绑定了，因此我们可以将这个数的相反数压入栈中;
- 当一个数前面是 '*' 号的时候，这一个数可以立即与前面的一个数相乘，此时我们让将栈顶的元素乘上这个数;
- 当一个数前面是 '/' 号的时候，这一个数也是可以立即被计算的，因此我们让栈顶元素除以这个数。
当遍历完全部的表达式的时候，栈中剩余的「元素之和」就是最终结果。
class Solution {
public:int calculate(string s){vector<int> vv;char op = '+';int tmp = 0;int i = 0;while (i < s.size()){while(s[i] == ' '){i++;}//遇到操作符更新操作符if (!(0 <= s[i] - '0' &&(s[i]-'0') <= 9))op = s[i++];//消除空格while (s[i] == ' '){i++;}//遇到数字提取数字while (0 <=(s[i]-'0')&&(s[i]-'0')<=9){tmp *= 10;tmp += s[i] - '0';i++;}while (s[i] == ' '){i++;}//分类讨论if (op == '+'){vv.push_back(tmp);}if (op == '-'){vv.push_back(-tmp);}if (op == '*'){int num = vv[vv.size() - 1] * tmp;vv.pop_back();vv.push_back(num);}if (op == '/'){int num = vv[vv.size() - 1] / tmp;vv.pop_back();vv.push_back(num);}tmp = 0;}int sum = 0;for (int x : vv){sum += x;}return sum;}
};4.字符串解码
给定一个经过编码的字符串，返回它解码后的字符串。
编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。
你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。
此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。
示例 1：
输入：s = "3[a]2[bc]" 输出："aaabcbc"
示例 2：
输入：s = "3[a2[c]]" 输出："accaccacc"
示例 3：
输入：s = "2[abc]3[cd]ef" 输出："abcabccdcdcdef"
解法(两个栈):
算法思路:
对于 3[ab2[cd]]，我们需要先解码内部的，再解码外部(为了方便区分，使用了空格):
3[ab2[cd]]->3[abcd cd]-> abcdcd abcdcd abcdcd在解码 cd 的时候，我们需要保存 3 ab 2 这些元素的信息，并且这些信息使用的顺序是从后往前，正好符合栈的结构，因此我们可以定义两个栈结构，一个用来保存解码前的重复次数 k(左括号前的数字)，一个用来保存解码之前字符串的信息(左括号前的字符串信息)。
class Solution {
public:string decodeString(string s) {vector<int> istack;vector<string> sstack;sstack.push_back("");int i=0;while(i<s.size()){ //1.遇到数字，提取放入栈int tmp=0;while(0<=(s[i]-'0')&&(s[i]-'0')<=9){tmp*=10;tmp+=s[i]-'0';i++;}if(tmp)istack.push_back(tmp);//2.到'[',提取字符串if(s[i]=='['){i++;string str;while('a'<=s[i]&&s[i]<='z'){str+=s[i++];}sstack.push_back(str);str.clear();}//3.遇到']',解析，放入字符串if(s[i]==']'){string str;int k=istack[istack.size()-1];istack.pop_back();string ttr=sstack[sstack.size()-1];sstack.pop_back();for(int j=0;j<k;j++){str+=ttr;}sstack[sstack.size()-1]+=str;str.clear();i++;}//4.遇到单独字符串，放到栈顶字符串后面string str;while('a'<=s[i]&&s[i]<='z'){str+=s[i++];}sstack[sstack.size()-1]+=str;str.clear();}return sstack[sstack.size()-1];}
};5. 验证栈序列
给定 pushed 和 popped 两个序列，每个序列中的 值都不重复，只有当它们可能是在最初空栈上进行的推入 push 和弹出 pop 操作序列的结果时，返回 true；否则，返回 false 。
示例 1：
输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1] 输出：true 解释：我们可以按以下顺序执行： push(1), push(2), push(3), push(4), pop() -> 4, push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
示例 2：
输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2] 输出：false 解释：1 不能在 2 之前弹出。
解法(栈):
算法思路:
用栈来模拟进出栈的流程。
一直让元素进栈，进栈的同时判断是否需要出栈。当所有元素模拟完毕之后，如果栈中还有元素，那么就是一个非法的序列。否则，就是一个合法的序列。
class Solution {
public:bool validateStackSequences(vector<int>& pushed, vector<int>& popped){int i = 0;vector<int> istack;int j = 0;while (j < pushed.size()){istack.push_back(pushed[j++]);while (istack.size() && istack[istack.size()-1] == popped[i]){istack.pop_back();i++;}}return i == popped.size();}
};
)
)
