1. 栈的基本概念与STL实现
栈（Stack）是一种遵循"后进先出"（LIFO, Last In First Out）原则的线性数据结构。想象一下餐厅里叠放的盘子——你总是取走最上面的那个盘子，而新洗好的盘子也会被放在最上面。这种特性使得栈在解决特定类型的问题时非常高效。
C++标准模板库（STL）中的stack容器适配器为我们提供了现成的栈实现。与手动实现的栈相比，STL版本有几个显著优势：
- 自动内存管理：STL栈会自动处理内存分配和释放，开发者无需担心内存泄漏问题
- 类型安全：通过模板机制，可以创建存储任何数据类型的栈
- 高效实现：底层通常基于
deque或list实现，操作时间复杂度均为O(1) - 异常安全：提供了基本的异常保证，确保操作失败时程序状态的一致性
注意：虽然STL栈默认使用deque作为底层容器，但也可以通过第二个模板参数指定其他容器类型，如
stack<int, vector<int>>。不过在实际开发中，除非有特殊需求，否则建议使用默认实现。
2. STL栈的核心操作详解
2.1 栈的声明与初始化
创建一个STL栈非常简单，只需包含<stack>头文件并指定元素类型：
cpp复制#include <stack>
using namespace std;
stack<int> intStack; // 存储整数的栈
stack<string> strStack; // 存储字符串的栈
stack<double> dblStack; // 存储双精度浮点数的栈
在实际工程中，有几点需要注意：
- 类型一致性：栈中所有元素必须是同一类型，这是模板容器的基本要求
- 命名规范：建议使用有意义的名称，如
undoStack、callStack等，提高代码可读性 - 作用域管理：栈对象的作用域决定了其生命周期，全局栈和局部栈的使用场景不同
2.2 元素压栈（push操作）
push()操作用于向栈顶添加新元素：
cpp复制stack<int> s;
s.push(10); // 栈：[10]
s.push(20); // 栈：[20, 10]
s.push(30); // 栈：[30, 20, 10]
关于push操作有几个实用技巧：
-
批量压栈：可以使用循环结构批量添加元素
cpp复制for(int i = 1; i <= 5; ++i) { s.push(i * 10); } // 栈：[50, 40, 30, 20, 10] -
移动语义：C++11后支持移动语义，可以高效转移对象所有权
cpp复制string str = "example"; stack<string> strStack; strStack.push(std::move(str)); // 移动而非拷贝 -
性能考虑：STL栈的push操作平均时间复杂度为O(1)，但可能触发底层容器扩容
2.3 元素出栈（pop操作）
pop()操作移除栈顶元素但不返回该元素：
cpp复制stack<int> s;
s.push(10); s.push(20); s.push(30);
// 栈：[30, 20, 10]
s.pop(); // 移除30，栈：[20, 10]
s.pop(); // 移除20，栈：[10]
关键注意事项：
-
空栈检查：必须在使用pop前检查栈是否为空
cpp复制if(!s.empty()) { s.pop(); } -
获取栈顶值：如果需要获取被移除的元素，必须先调用top()
cpp复制if(!s.empty()) { int topValue = s.top(); // 获取栈顶值 s.pop(); // 移除栈顶元素 } -
异常安全：pop操作不抛出异常，但空栈调用是未定义行为
2.4 访问栈顶元素（top操作）
top()返回栈顶元素的引用，允许读取或修改：
cpp复制stack<int> s;
s.push(10); s.push(20);
// 栈：[20, 10]
int& top = s.top(); // 获取引用
top = 25; // 修改栈顶元素
// 栈：[25, 10]
使用top时的最佳实践：
-
const版本：如果不需要修改，可以使用const引用避免意外修改
cpp复制const int& top = const_cast<const stack<int>&>(s).top(); -
生命周期：返回的引用在栈结构改变（push/pop）后失效
-
性能：top操作是O(1)时间复杂度，非常高效
2.5 栈的状态检查
empty()和size()用于检查栈的状态：
cpp复制stack<int> s;
cout << "Empty: " << s.empty() << endl; // 输出1(true)
cout << "Size: " << s.size() << endl; // 输出0
s.push(10); s.push(20);
cout << "Empty: " << s.empty() << endl; // 输出0(false)
cout << "Size: " << s.size() << endl; // 输出2
性能比较：
empty()：通常直接比较首尾指针，O(1)时间复杂度size()：可能需要计算元素数量，某些实现中可能比empty稍慢
3. 栈的典型应用场景
3.1 括号匹配问题
这是栈的经典应用，用于检查表达式中的括号是否合法：
cpp复制bool isBalanced(const string& expr) {
stack<char> s;
for(char c : expr) {
if(c == '(' || c == '[' || c == '{') {
s.push(c);
} else {
if(s.empty()) return false;
char top = s.top(); s.pop();
if((c == ')' && top != '(') ||
(c == ']' && top != '[') ||
(c == '}' && top != '{')) {
return false;
}
}
}
return s.empty();
}
算法分析：
- 时间复杂度：O(n)，每个元素只处理一次
- 空间复杂度：O(n)，最坏情况下需要存储所有左括号
3.2 表达式求值
栈可用于中缀表达式转后缀表达式（逆波兰表示法），以及后续的求值：
cpp复制// 简化的中缀转后缀示例
string infixToPostfix(const string& infix) {
stack<char> opStack;
string postfix;
// 实现细节省略...
return postfix;
}
3.3 函数调用栈
计算机系统使用调用栈管理函数调用：
- 每次函数调用时，返回地址和局部变量被压栈
- 函数返回时，从栈中弹出这些信息
- 递归过深会导致栈溢出
3.4 撤销操作(Undo)实现
许多应用程序使用栈实现撤销功能：
cpp复制class Editor {
stack<string> undoStack;
string content;
public:
void edit(const string& newContent) {
undoStack.push(content);
content = newContent;
}
void undo() {
if(!undoStack.empty()) {
content = undoStack.top();
undoStack.pop();
}
}
};
4. 栈的高级用法与性能优化
4.1 自定义底层容器
STL允许指定底层容器类型：
cpp复制#include <vector>
#include <stack>
stack<int, vector<int>> vecStack; // 使用vector作为底层容器
不同容器的性能特点：
deque（默认）：两端操作高效，内存非连续vector：内存连续，但只在末尾高效list：任何位置操作高效，但内存开销大
4.2 栈的交换操作
两个栈可以高效交换内容：
cpp复制stack<int> s1, s2;
// ...填充栈...
s1.swap(s2); // 交换内容
4.3 避免不必要的拷贝
使用emplace直接构造元素：
cpp复制stack<pair<int, string>> s;
s.emplace(10, "example"); // 直接在栈中构造pair
4.4 栈的迭代问题
STL栈不提供迭代器接口，如需遍历：
- 创建临时副本
- 通过pop操作逐个访问
- 考虑是否需要使用其他数据结构
5. 常见问题与调试技巧
5.1 空栈访问错误
问题现象：程序崩溃，显示segmentation fault
原因：对空栈调用了top()或pop()
解决方案：
cpp复制if(!s.empty()) {
// 安全操作
s.top(); s.pop();
}
5.2 类型不匹配错误
问题现象：编译错误，提示类型不兼容
原因：push了错误类型的元素
解决方案：
cpp复制stack<int> s;
// s.push("string"); // 错误
s.push(123); // 正确
5.3 栈溢出问题
问题现象：程序崩溃，栈空间耗尽
原因：递归过深或超大栈
解决方案：
- 改用迭代算法
- 增加栈空间（系统配置）
- 使用堆分配的数据结构
5.4 性能优化建议
- 预分配空间：如果知道大致大小，可以预先reserve底层容器空间
- 批量操作：尽量减少单元素操作，考虑批量处理
- 移动语义：对于复杂对象，使用移动而非拷贝
6. 栈与其他数据结构的比较
6.1 栈 vs 队列
| 特性 | 栈 | 队列 |
|---|---|---|
| 顺序 | LIFO | FIFO |
| 操作 | 一端操作 | 两端操作 |
| 应用 | 函数调用、表达式求值 | 任务调度、缓冲 |
6.2 栈 vs 向量/列表
| 特性 | 栈 | 向量/列表 |
|---|---|---|
| 访问 | 仅栈顶 | 任意元素 |
| 插入 | 仅压栈 | 任意位置 |
| 删除 | 仅弹栈 | 任意位置 |
| 实现 | 适配器 | 独立容器 |
7. 实际工程案例：浏览器历史记录实现
cpp复制class BrowserHistory {
stack<string> backStack;
stack<string> forwardStack;
string current;
public:
BrowserHistory(string homepage) : current(homepage) {}
void visit(string url) {
backStack.push(current);
current = url;
// 清空前进栈
forwardStack = stack<string>();
}
string back(int steps) {
while(steps-- && !backStack.empty()) {
forwardStack.push(current);
current = backStack.top();
backStack.pop();
}
return current;
}
string forward(int steps) {
while(steps-- && !forwardStack.empty()) {
backStack.push(current);
current = forwardStack.top();
forwardStack.pop();
}
return current;
}
};
这个实现展示了如何用双栈实现浏览器的前进后退功能，体现了栈在实际工程中的应用价值。