《栈：后进先出的程序魔法盒》

鱼鱼块
3 阅读6分钟

栈：程序世界里的“后进先出”魔法盒

在计算机科学的世界里，有一种看似简单却无处不在的数据结构——栈（Stack） 。它就像一个只能从顶部放入或取出物品的魔法盒子：你最后放进去的东西，总是最先被拿出来。这种“后进先出”（Last In, First Out，简称 LIFO）的特性，让它成为许多程序逻辑背后的关键支撑。

无论是你在浏览器中点击“返回”按钮回到上一个页面，还是编辑器自动检查括号是否配对，甚至函数调用时的内存管理，都离不开栈的身影。那么，栈到底是什么？程序员又是如何实现它的？不同的实现方式又各有什么优劣？本文将带你一探究竟。

什么是栈？

栈是一种线性数据结构，只允许在一端进行操作——这一端称为“栈顶”。你可以执行两种基本操作：

  • 入栈（Push） ：把一个元素放到栈顶；
  • 出栈（Pop） ：把栈顶的元素取出来。

除此之外，通常还会提供：

  • 查看栈顶（Peek/Top） ：看看最上面是什么，但不拿走；
  • 判断是否为空（IsEmpty） ；
  • 获取大小（Size） 。

这些操作共同构成了栈的“行为契约”，无论底层怎么实现，对外表现都是一致的。

如何实现一个栈？

在编程中，实现栈主要有两种方式：基于数组和基于链表。现代编程语言（如 JavaScript、Python、Java 等）通常会提供这两种思路的变体，而开发者可以根据需求选择最适合的方案。

1. 数组实现：简洁高效，但有“扩容烦恼”

数组是一段连续的内存空间，天然支持在末尾快速添加或删除元素。因此，用数组实现栈非常直观：

// 创建一个空栈
const stack = [];

// 入栈
stack.push(10);
stack.push(20);

// 查看栈顶
console.log(stack[stack.length - 1]); // 输出 20

// 出栈
const top = stack.pop(); // 返回 20

这种方式代码简短、运行高效。在大多数情况下，push 和 pop 操作的时间复杂度都是 O(1) ，速度极快。

但有一个潜在问题：当数组装不下更多元素时，系统会自动“扩容” ——分配一块更大的内存，把旧数据全部复制过去。这个过程虽然不常发生，但一旦触发，时间复杂度会瞬间变成 O(n) 。好在现代语言的扩容策略很聪明（比如每次扩大1.5倍），所以平均来看性能依然优秀。

不过，如果一开始分配了很大空间，后来又没用完，就会造成内存浪费。因此，数组实现更适合元素数量相对稳定的场景。

为了提升安全性与可维护性，程序员往往会将数组封装在一个类中，隐藏内部细节：

class ArrayStack {
  #items = []; // 私有属性，外部无法直接访问

  push(value) {
    this.#items.push(value);
  }

  pop() {
    if (this.isEmpty()) throw new Error("栈为空！");
    return this.#items.pop();
  }

  peek() {
    if (this.isEmpty()) throw new Error("栈为空！");
    return this.#items[this.#items.length - 1];
  }

  isEmpty() {
    return this.#items.length === 0;
  }

  get size() {
    return this.#items.length;
  }
}

通过私有字段（以 # 开头）和方法封装，既保护了数据安全，又提供了清晰的接口。

2. 链表实现：灵活稳定，但略“费空间”

链表由一个个独立的“节点”组成，每个节点除了存储数据，还保存着指向下一个节点的“指针”。用链表实现栈时，我们只需让新节点始终指向当前的栈顶，然后把栈顶更新为这个新节点即可。

class ListNode {
  constructor(val) {
    this.val = val;
    this.next = null;
  }
}

class LinkedListStack {
  #top = null; // 栈顶指针
  #size = 0;

  push(value) {
    const node = new ListNode(value);
    node.next = this.#top;
    this.#top = node;
    this.#size++;
  }

  pop() {
    if (!this.#top) throw new Error("栈为空！");
    const value = this.#top.val;
    this.#top = this.#top.next;
    this.#size--;
    return value;
  }

  peek() {
    if (!this.#top) throw new Error("栈为空！");
    return this.#top.val;
  }

  isEmpty() {
    return this.#size === 0;
  }

  get size() {
    return this.#size;
  }
}

这种方式的好处是：

  • 永远不会“满” ——需要多少空间就申请多少；
  • 每次操作都是 O(1) ，没有扩容带来的性能波动；
  • 内存使用更“按需分配”。

但代价也很明显：

  • 每个节点都要额外存储一个指针，占用更多内存；
  • 节点分散在内存各处，访问速度不如连续数组快；
  • 频繁创建和销毁对象可能增加系统负担。

因此，链表实现更适合数据量变化剧烈或对操作稳定性要求极高的场合。

栈的经典应用：验证括号是否匹配(20. 有效的括号 - 力扣（LeetCode）

栈的一个经典用途是检查字符串中的括号是否正确配对。比如 "([{}])" 是合法的，而 "([)]" 则不是。

解决思路很简单：

  1. 遇到左括号（(、[、{），就把对应的右括号压入栈；
  2. 遇到右括号，就检查它是否和栈顶一致；
  3. 如果不一致，或栈已空，说明不匹配；
  4. 最后如果栈为空，说明全部匹配成功。

代码如下：

function isValid(s) {
  const leftToRight = { '(': ')', '[': ']', '{': '}' };
  const stack = [];

  for (let i = 0; i < s.length; i++) {
    const ch = s[i];
    if (ch in leftToRight) {
      stack.push(leftToRight[ch]); // 压入期望的右括号
    } else {
      if (stack.length === 0 || stack.pop() !== ch) {
        return false; // 不匹配
      }
    }
  }

  return stack.length === 0; // 栈空才有效
}

这个算法清晰、高效，完美体现了栈“后进先出”的威力。

数组 vs 链表：如何选择？

维度数组实现链表实现
时间效率平均 O(1)，扩容时 O(n)始终 O(1)
空间效率连续内存，无指针开销每节点多一个指针，空间开销大
缓存友好性高（连续内存利于CPU缓存）低（节点分散）
实现复杂度极简稍复杂
适用场景元素数量稳定、追求高性能元素数量波动大、要求稳定性

对于大多数日常开发任务，数组实现已经足够优秀。只有在极端场景（如嵌入式系统、高频交易等）下，才需要考虑链表带来的稳定性优势。

封装的意义：不只是“能用”，更要“好用”

直接使用原生数组虽然方便，但在大型项目中容易出错。比如，不小心从中间删除了元素，或者误读了无效位置的数据。通过类封装，我们可以：

  • 隐藏内部实现细节；
  • 提供统一、安全的操作接口；
  • 加入错误处理（如空栈弹出时抛出异常）；
  • 未来轻松更换底层实现而不影响外部代码。

这正是软件工程中“高内聚、低耦合”思想的体现。

结语

栈虽小，却是程序世界的“隐形英雄”。它用最朴素的规则，解决了无数复杂的逻辑问题。理解栈的原理与实现，不仅能帮助我们写出更高效的代码，也能让我们更深入地洞察计算机是如何“思考”的。

下次当你按下浏览器的“返回”键，或看到编辑器高亮一对括号时，不妨想一想：背后或许正有一个小小的栈，在默默为你服务。

avatar
文章
阅读
粉丝