孔良1. 栈的基本概念与核心特性
栈（Stack）是一种操作受限的线性数据结构，它遵循后进先出（LIFO, Last In First Out）的原则。这个特性就像我们日常生活中叠放的盘子——最后放上去的盘子总是最先被取用。在计算机科学中，栈的应用无处不在，从函数调用、表达式求值到浏览器历史记录管理，都离不开这种简洁而强大的数据结构。
栈的核心操作通常包括：
- push（入栈）：将元素添加到栈顶
- pop（出栈）：移除并返回栈顶元素
- peek（查看栈顶）：返回但不移除栈顶元素
- isEmpty（判空）：检查栈是否为空
- size（大小）：返回栈中元素数量
注意：不同编程语言中这些操作的命名可能略有差异。例如在Java中查看栈顶元素的方法名为peek()，而在Python中则通常使用top()。
栈的底层实现主要有两种方式：
- 基于数组的静态实现：预先分配固定大小的连续内存空间
- 基于链表的动态实现：元素通过指针动态连接，内存按需分配
数组实现的优势在于内存局部性好，访问速度快；而链表实现则更灵活，不受固定容量限制。在Java中，Stack类就是基于数组实现的，而C++中的stack默认是基于deque实现的混合结构。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 使用ArrayList实现栈结构
ArrayList作为动态数组的实现，非常适合用来模拟栈的行为。下面我们来看一个完整的Java实现示例：
java复制import java.util.ArrayList;
public class ArrayListStack<T> {
private ArrayList<T> stackList;
public ArrayListStack() {
stackList = new ArrayList<>();
}
// 入栈操作
public void push(T item) {
stackList.add(item);
}
// 出栈操作
public T pop() {
if (isEmpty()) {
throw new RuntimeException("Stack is empty");
}
return stackList.remove(stackList.size() - 1);
}
// 查看栈顶元素
public T peek() {
if (isEmpty()) {
throw new RuntimeException("Stack is empty");
}
return stackList.get(stackList.size() - 1);
}
// 判断栈是否为空
public boolean isEmpty() {
return stackList.isEmpty();
}
// 获取栈大小
public int size() {
return stackList.size();
}
}
这个实现有几个值得注意的技术细节：
-
泛型设计：使用泛型T使得栈可以存储任意类型的数据，提高了代码的复用性。
-
异常处理：在pop和peek操作中，我们对空栈情况进行了检查并抛出运行时异常。在实际项目中，可能需要根据业务需求自定义异常类型。
-
时间复杂度：
- push操作：平均O(1)（考虑ArrayList的动态扩容）
- pop操作：O(1)
- peek操作：O(1)
- size操作：O(1)
ArrayList实现的一个潜在问题是当元素数量超过初始容量时需要进行数组扩容和数据拷贝。虽然ArrayList的扩容策略（通常是增长50%）使得均摊时间复杂度仍为O(1)，但在对性能极其敏感的场景下，这种不确定性可能成为问题。
3. 基于StringBuilder的栈实现技巧
StringBuilder虽然主要用于字符串操作，但我们可以巧妙地利用其特性来实现一个高效的字符栈。这种实现特别适合处理字符串相关的算法问题，如括号匹配、逆波兰表达式等。
java复制public class StringBuilderStack {
private StringBuilder stackBuilder;
private int top;
public StringBuilderStack() {
stackBuilder = new StringBuilder();
top = -1;
}
public void push(char c) {
stackBuilder.append(c);
top++;
}
public char pop() {
if (isEmpty()) {
throw new RuntimeException("Stack is empty");
}
char c = stackBuilder.charAt(top);
stackBuilder.deleteCharAt(top);
top--;
return c;
}
public char peek() {
if (isEmpty()) {
throw new RuntimeException("Stack is empty");
}
return stackBuilder.charAt(top);
}
public boolean isEmpty() {
return top == -1;
}
}
这种实现有几个独特的优势：
-
内存效率：StringBuilder内部使用字符数组存储数据，比使用ArrayList
更节省内存，因为避免了Character对象的装箱开销。 -
字符串操作便利：当栈用于处理字符串问题时，可以方便地调用StringBuilder的其他方法，如reverse()、substring()等。
-
性能优化：StringBuilder的append和deleteCharAt操作都经过高度优化，特别适合高频的字符入栈出栈场景。
不过需要注意，这种实现是专门为字符栈设计的，不具备通用性。在实际开发中，如果栈需要存储多种类型的数据，还是应该选择基于ArrayList或链表的实现。
4. 栈的实现方式性能对比与选型建议
不同的栈实现在性能特性上有着显著差异。下面我们通过表格对比几种常见实现的特点：
| 实现方式 | 时间复杂度 | 空间复杂度 | 适用场景 | 缺点 |
|---|---|---|---|---|
| 数组(固定大小) | 所有操作O(1) | O(n)固定 | 已知最大容量场景 | 容量有限 |
| ArrayList(动态) | push均摊O(1),其他O(1) | O(n)动态 | 通用场景 | 扩容时短暂性能下降 |
| LinkedList | 所有操作O(1) | O(n)每个节点额外指针 | 频繁增删 | 内存开销大 |
| StringBuilder | 所有操作O(1) | O(n)紧凑 | 字符处理专用 | 仅限字符 |
在实际项目中选择栈的实现时，需要考虑以下因素：
-
数据类型：如果只需要处理基本类型（特别是char），可以考虑专用实现如StringBuilder；对于复杂对象，则需要通用实现。
-
性能需求：对性能极其敏感的场景，可能需要预先分配足够空间的数组实现；对于一般业务逻辑，ArrayList通常是最佳选择。
-
内存限制：在内存受限的环境（如嵌入式系统）中，固定大小的数组实现可能更合适。
-
并发需求：如果栈需要在多线程环境下使用，需要考虑线程安全的实现，如Java中的ConcurrentLinkedDeque，或者使用同步包装器：
java复制Stack<T> stack = Collections.synchronizedStack(new Stack<T>()); -
功能扩展：如果需要栈支持遍历、中间元素访问等非标准操作，基于LinkedList的实现可能更灵活。
5. 栈的常见应用场景与算法实践
栈在算法和实际工程中有着广泛的应用。下面我们通过几个典型场景来深入理解栈的威力。
5.1 括号匹配问题
括号匹配是栈的经典应用，用于检查表达式中的括号是否正确嵌套。算法思路如下：
- 初始化一个空栈
- 遍历字符串中的每个字符：
- 遇到左括号（'('、'['、'{'）则入栈
- 遇到右括号则检查栈顶是否匹配的左括号
- 如果匹配则弹出栈顶
- 否则返回不匹配
- 最后检查栈是否为空
java复制public boolean isValid(String s) {
Stack<Character> stack = new Stack<>();
for (char c : s.toCharArray()) {
if (c == '(' || c == '[' || c == '{') {
stack.push(c);
} else {
if (stack.isEmpty()) return false;
char top = stack.pop();
if ((c == ')' && top != '(') ||
(c == ']' && top != '[') ||
(c == '}' && top != '{')) {
return false;
}
}
}
return stack.isEmpty();
}
5.2 逆波兰表达式求值
逆波兰表达式（后缀表达式）的计算天然适合用栈来实现：
java复制public int evalRPN(String[] [token](https://taotoken.net?utm_source=general)s) {
Stack<Integer> stack = new Stack<>();
for (String token : tokens) {
if (token.equals("+")) {
stack.push(stack.pop() + stack.pop());
} else if (token.equals("-")) {
int b = stack.pop(), a = stack.pop();
stack.push(a - b);
} else if (token.equals("*")) {
stack.push(stack.pop() * stack.pop());
} else if (token.equals("/")) {
int b = stack.pop(), a = stack.pop();
stack.push(a / b);
} else {
stack.push(Integer.parseInt(token));
}
}
return stack.pop();
}
5.3 函数调用栈
在程序执行过程中，函数调用是通过栈来管理的。每次调用新函数时，会将返回地址和局部变量等信息压入调用栈；函数返回时则弹出栈顶元素。理解这一点对调试递归算法尤为重要。
java复制// 递归实现的阶乘函数
public int factorial(int n) {
if (n <= 1) return 1; // 基本情况
return n * factorial(n - 1); // 递归调用
}
每次递归调用都会在调用栈中创建一个新的栈帧，直到达到基本情况才开始逐层返回。如果递归深度过大（如n很大），会导致栈溢出错误（StackOverflowError）。
6. 栈的边界条件与异常处理
在实际使用栈时，必须特别注意各种边界条件和异常情况。以下是几个常见的陷阱：
-
空栈操作：尝试对空栈执行pop或peek操作是最常见的错误。如我们前面的实现所示，这些操作前必须检查栈是否为空。
-
容量限制：对于固定大小的数组实现，push操作可能引发栈溢出。即使使用动态数组，极端情况下也可能耗尽内存。
-
并发修改：在多线程环境中，如果栈被多个线程共享且没有适当的同步措施，可能导致数据损坏。
-
对象相等性：当栈中存储的是对象而非基本类型时，要注意equals和hashCode的实现是否正确，特别是在执行搜索操作时。
-
内存泄漏：在某些语言（如C++）中，如果栈中存储的是指针，需要在弹出时确保适当地释放内存；在Java等有垃圾回收的语言中，长期持有的引用可能导致对象无法被回收。
针对这些潜在问题，我们可以采取以下防御性编程措施：
- 在pop和peek操作前总是检查isEmpty()
- 对于固定大小实现，push前检查isFull()
- 在多线程环境中使用线程安全的栈实现
- 考虑实现迭代器来安全地遍历栈元素
- 对于资源敏感的对象，确保适当地清理
7. 栈的变体与高级应用
除了基本的LIFO栈外，还存在多种栈的变体，它们扩展了栈的功能和应用场景：
7.1 最小栈（Min Stack）
最小栈支持在O(1)时间内获取栈中的最小元素。实现思路是使用辅助栈同步记录当前最小值：
java复制class MinStack {
private Stack<Integer> dataStack;
private Stack<Integer> minStack;
public MinStack() {
dataStack = new Stack<>();
minStack = new Stack<>();
}
public void push(int x) {
dataStack.push(x);
if (minStack.isEmpty() || x <= minStack.peek()) {
minStack.push(x);
} else {
minStack.push(minStack.peek());
}
}
public void pop() {
dataStack.pop();
minStack.pop();
}
public int top() {
return dataStack.peek();
}
public int getMin() {
return minStack.peek();
}
}
7.2 双栈队列
用两个栈可以实现一个队列的FIFO行为。一个栈用于入队，另一个用于出队：
java复制class MyQueue {
private Stack<Integer> inStack;
private Stack<Integer> outStack;
public MyQueue() {
inStack = new Stack<>();
outStack = new Stack<>();
}
public void push(int x) {
inStack.push(x);
}
public int pop() {
if (outStack.isEmpty()) {
while (!inStack.isEmpty()) {
outStack.push(inStack.pop());
}
}
return outStack.pop();
}
public int peek() {
if (outStack.isEmpty()) {
while (!inStack.isEmpty()) {
outStack.push(inStack.pop());
}
}
return outStack.peek();
}
public boolean empty() {
return inStack.isEmpty() && outStack.isEmpty();
}
}
7.3 浏览器历史记录
浏览器的前进后退功能可以通过两个栈来实现：一个栈存储后退历史，另一个栈存储前进历史。当用户点击后退时，从后退栈弹出并压入前进栈；前进时则相反。
java复制class BrowserHistory {
private Stack<String> backStack;
private Stack<String> forwardStack;
private String current;
public BrowserHistory(String homepage) {
backStack = new Stack<>();
forwardStack = new Stack<>();
current = homepage;
}
public void visit(String url) {
backStack.push(current);
current = url;
forwardStack.clear(); // 清空前进历史
}
public String back(int steps) {
while (steps-- > 0 && !backStack.isEmpty()) {
forwardStack.push(current);
current = backStack.pop();
}
return current;
}
public String forward(int steps) {
while (steps-- > 0 && !forwardStack.isEmpty()) {
backStack.push(current);
current = forwardStack.pop();
}
return current;
}
}
8. 栈在算法竞赛中的优化技巧
在算法竞赛中，栈的应用往往需要一些优化技巧来提高性能。以下是几个实用的高级技巧：
- 数组模拟栈：在已知最大数据规模的情况下，用数组和指针模拟栈比使用库中的栈类更快。
java复制// 数组模拟栈示例
int[] stack = new int[10000];
int top = -1;
// push操作
stack[++top] = value;
// pop操作
value = stack[top--];
-
延迟操作：某些问题中，可以延迟执行某些栈操作，批量处理以提高效率。
-
哨兵节点：在栈底预先放入一个特殊值（如最小值）作为哨兵，可以简化边界条件判断。
-
栈内信息压缩：对于某些特定问题，可以在栈中存储计算后的信息而非原始数据，减少后续计算量。
-
单调栈技巧：维护栈内元素的单调性（递增或递减），可以高效解决一类特定问题，如柱状图中最大矩形、下一个更大元素等。
java复制// 下一个更大元素问题
public int[] nextGreaterElement(int[] nums) {
int[] result = new int[nums.length];
Stack<Integer> stack = new Stack<>();
for (int i = nums.length - 1; i >= 0; i--) {
while (!stack.isEmpty() && stack.peek() <= nums[i]) {
stack.pop();
}
result[i] = stack.isEmpty() ? -1 : stack.peek();
stack.push(nums[i]);
}
return result;
}
在实际编码中，我发现合理选择栈的实现方式对性能影响很大。对于算法竞赛，通常推荐使用数组模拟栈；而对于业务开发，标准库中的栈实现通常更安全可靠。当处理字符串相关问题时，StringBuilder实现的字符栈往往能提供最佳性能。