栈：先进后出的线性数据结构及其在JavaScript中的优雅实现

Lee川
4 阅读6分钟

引言

在计算机科学的浩瀚宇宙中，数据结构如同星辰般璀璨，而栈（Stack）作为最基础、最优雅的线性数据结构之一，以其"先进后出"（FILO）的特性，默默支撑着无数算法与程序的运行。今天，让我们深入探索栈的本质，以及在JavaScript中如何用现代语法优雅地实现它。

一、栈：FILO的优雅哲学

栈，顾名思义，是一种遵循"后进先出"原则的线性数据结构。想象一下现实中的书堆——你最后放上去的书，会最先被取走。这种简单的逻辑在计算机科学中有着广泛的应用，从函数调用堆栈到表达式求值，从括号匹配到浏览器的前进后退功能，栈的身影无处不在。

栈的抽象数据类型（ADT）

栈的ADT定义了其核心操作，这些操作构成了栈的"灵魂"：

  • push(item): 将元素添加到栈顶
  • pop(): 移除并返回栈顶元素
  • peek(): 查看栈顶元素但不移除
  • isEmpty(): 检查栈是否为空
  • size(): 获取栈中元素的数量

这些操作构成了栈的"语言"，无论我们用何种方式实现，都必须遵守这些规则。

二、JavaScript中的栈实现：数组与链表的对决

在JavaScript中，我们可以用两种主要方式实现栈：基于数组和基于链表。每种方式都有其独特的优势和局限性，让我们深入剖析。

1. 基于数组的栈实现

数组是JavaScript中开箱即用的线性数据结构，因此用数组实现栈最为直接：

class ArrayStack {
  #stack;
  
  constructor() {
    this.#stack = [];
  }
  
  get size() {
    return this.#stack.length;
  }
  
  isEmpty() {
    return this.size === 0;
  }
  
  push(num) {
    this.#stack.push(num);
  }
  
  pop() {
    if (this.isEmpty()) throw new Error('栈为空');
    return this.#stack.pop();
  }
  
  peek() {
    if (this.isEmpty()) throw new Error('栈为空');
    return this.#stack[this.size - 1];
  }
  
  toArray() {
    return this.#stack;
  }
}

优点：

  • 代码简洁易懂，利用了JavaScript内置的数组方法
  • 数组的尾部操作（push和pop）时间复杂度为O(1)
  • 对于中小型数据集，性能优越

缺点：

  • 当数组容量不足时，需要触发扩容操作（将所有元素复制到新数组），时间复杂度为O(n)
  • 虽然扩容是低频操作，但会带来短暂的性能波动
  • 可能造成一定的空间浪费（预留的数组空间）

2. 基于链表的栈实现

链表为栈提供了另一种优雅的实现方式，特别适合需要稳定性能的场景：

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

class LinkedListStack {
  #stackPeek;
  #size = 0;
  
  constructor() {
    this.#stackPeek = null;
  }
  
  push(num) {
    const node = new ListNode(num);
    node.next = this.#stackPeek;
    this.#stackPeek = node;
    this.#size++;
  }
  
  peek() {
    if (!this.#stackPeek) throw new Error('栈为空');
    return this.#stackPeek.val;
  }
  
  pop() {
    const num = this.peek();
    this.#stackPeek = this.#stackPeek.next;
    this.#size--;
    return num;
  }
  
  get size() {
    return this.#size;
  }
  
  isEmpty() {
    return this.#size === 0;
  }
  
  toArray() {
    let node = this.#stackPeek;
    const res = new Array(this.size);
    for (let i = res.length - 1; i >= 0; i--) {
      res[i] = node.val;
      node = node.next;
    }
    return res;
  }
}

优点：

  • 没有扩容问题，每次push和pop操作都是O(1)的时间复杂度
  • 空间利用更高效，没有预留空间的浪费
  • 适合处理大规模数据或需要稳定性能的场景

缺点：

  • 实现相对复杂，需要管理链表节点
  • 链表节点需要额外的空间存储指针，单个节点的内存开销略大

三、数组 vs 链表：性能与空间的权衡

在选择栈的实现方式时，我们需要权衡性能和空间效率：

特性基于数组的栈基于链表的栈
时间效率平均O(1)，扩容时O(n)稳定O(1)
空间效率可能有空间浪费更高效，无浪费
实现复杂度简单中等
代码可读性高中等
适合场景中小型数据集、简单应用大型数据集、高性能需求

在实际应用中，如果栈的大小是可预知的且不会过大，基于数组的实现往往更简单高效；而当数据规模不确定或需要稳定性能时，基于链表的实现更为合适。

四、现代JavaScript的优雅实现：ES6的特性加持

ES6为类的实现带来了革命性的变化，让栈的实现更加优雅和安全：

  1. 私有字段（#）：使用#前缀定义私有字段，如#stack和#stackPeek，保护了类的实现细节，防止外部直接修改内部状态。

  2. 访问器属性（get/set）：如get size()，让我们可以像访问普通属性一样获取栈的大小，但背后执行的是计算逻辑。

  3. 类的封装：将实现细节封装在类内部，提供清晰的接口，使代码更易维护和理解。

这些特性使得栈的实现不仅功能强大，而且符合现代JavaScript的编码规范，提升了代码的可读性和可维护性。

五、栈的实际应用：力扣第20题的解法

栈在算法问题中有着广泛的应用，最经典的例子之一是力扣第20题"有效的括号"。这个问题要求判断一个由括号组成的字符串是否有效，如"()"、"()[]{}"等。

解法思路：

  1. 遍历字符串中的每个字符
  2. 如果是左括号（(、[、{），将其压入栈
  3. 如果是右括号，检查栈顶是否为对应的左括号
    • 如果匹配，弹出栈顶
    • 如果不匹配，返回false
  4. 遍历结束后，如果栈为空，返回true；否则返回false

代码实现：

function isValid(s) {
  const stack = new ArrayStack();
  const map = {
    ')': '(',
    ']': '[',
    '}': '{'
  };
  
  for (const char of s) {
    if (char === '(' || char === '[' || char === '{') {
      stack.push(char);
    } else {
      const top = stack.isEmpty() ? '#' : stack.pop();
      if (map[char] !== top) {
        return false;
      }
    }
  }
  
  return stack.isEmpty();
}

这个解法利用了栈的FILO特性，完美解决了括号匹配问题，展示了栈在算法中的强大应用。

六、结语：栈的永恒魅力

栈，这个看似简单的数据结构，却蕴含着计算机科学的深刻智慧。它以最简洁的方式，实现了最复杂的逻辑。从数组到链表，从ES5到ES6，栈的实现方式不断演进，但其核心理念——"后进先出"——始终如一。

在现代JavaScript开发中，理解栈的实现原理和应用场景，不仅能够帮助我们写出更高效、更优雅的代码，还能让我们在面对各种算法问题时，拥有更清晰的思路和更强大的工具。

正如古人所言："大道至简"，栈的简单本质恰恰是其强大之处。当我们熟练掌握栈的实现，便能在数据结构的世界中，如鱼得水，游刃有余。

无论你是初学者还是经验丰富的开发者，理解栈的精髓，都将是你编程生涯中一笔宝贵的财富。让我们在代码的海洋中，继续探索栈的无限可能！

avatar
文章
阅读
粉丝