数据结构-堆栈：计算机科学中的LIFO利器

最新推荐文章于 2025-12-15 09:16:00 发布

原创最新推荐文章于 2025-12-15 09:16:00 发布 · 1.4k 阅读

25 ·

CC 4.0 BY-SA版权

文章标签：

#.net #数据库

数据结构专栏收录该内容

5 篇文章

订阅专栏

当然，很乐意为您将关于“堆栈”的所有回答整合并扩展成一篇详尽、连贯的技术文档。

深度解析核心数据结构：堆栈 (A Deep Dive into the Core Data Structure: The Stack)

第一部分：什么是堆栈？核心概念与思想

在计算机科学中，堆栈（Stack）是一种基础且功能强大的抽象数据类型（ADT），它的工作模式非常符合直觉，可以用一个生活中的常见比喻来形容：一摞盘子。

1.1 核心原则：后进先出 (LIFO)

堆栈最根本的特性是后进先出（Last-In, First-Out，简称 LIFO）。

入栈 (Push)：当我们将一个新元素放入堆栈时，就好比把一个刚洗好的盘子放在这摞盘子的最上面。
出栈 (Pop)：当我们从堆栈中取出一个元素时，也只能从最上面拿走那个盘子。

这意味着，最后一个被放进去的元素，将会是第一个被取出来的元素。

1.2 栈顶与栈底

这个“盘子”的比喻也帮助我们理解堆栈的两个关键位置：

栈顶 (Stack Top)：比喻为最上面的盘子。它是堆栈中所有操作（入栈和出栈）发生的唯一位置，是堆栈“最活跃”的一端。
栈底 (Stack Bottom)：比喻为最下面的盘子。它是第一个被放入的元素，并且只有当它上面的所有元素都被取出后，它才能被访问到。

1.3 基本操作集 (ADT)

一个完整的堆栈ADT应支持以下核心操作：

Stack CreateStack(): 创建并返回一个空堆栈。
void Push(Stack S, ElementType item): 将元素 item 压入堆栈 S 的顶部。
ElementType Pop(Stack S): 从堆栈 S 的顶部弹出一个元素，并返回其值。
ElementType Top(Stack S): 查看栈顶元素的值，但不将其弹出。
int IsEmpty(Stack S): 检查堆栈 S 是否为空。

第二部分：经典应用 —— 表达式求值

堆栈的LIFO特性使其成为解决计算机领域一个经典问题——算术表达式求值——的完美工具。

2.1 问题的挑战：中缀表达式

人类习惯书写中缀表达式（Infix Expression），即运算符位于操作数之间，例如 5 + 6 / 2 - 3 * 4。我们能正确计算出结果为-4，是因为我们遵循“先乘除，后加减”的运算符优先级规则。

但对于计算机来说，直接处理这种带有复杂优先级和括号的表达式逻辑非常复杂。为了简化这一过程，计算机通常采用一种对机器更友好的表达式表示法。

2.2 解决方案：后缀与前缀表达式

后缀表达式 (Postfix Expression / 逆波兰表示法 RPN)：运算符位于其操作数之后。例如，a+b*c 变为 abc*+。
前缀表达式 (Prefix Expression / 波兰表示法 PN)：运算符位于其操作数之前。例如，a+b*c 变为 +a*bc。

这两种表示法的巨大优势在于它们彻底消除了括号和运算符优先级的歧义。运算符出现的顺序就是它们的计算顺序，这使得计算机求值过程变得异常简单和高效。

计算机处理表达式的通用策略是“两步走”：

转换：将用户输入的中缀表达式转换为后缀（或前缀）表达式。
求值：对转换后的表达式进行计算。

堆栈在这两个步骤中都扮演着至关重要的角色。

2.3 后缀表达式的求值算法

后缀表达式的求值策略是：从左到右扫描，逐个处理运算数和运算符。

当遇到运算数时，我们如何“记住”它们？当遇到运算符时，它对应的操作数又是哪几个？

答案就在堆栈的LIFO特性中。我们需要一个操作数栈。

算法规则：

从左到右扫描后缀表达式。
遇到操作数，将其压入堆栈。
遇到运算符，从堆栈中弹出两个操作数（后弹出的是左操作数，先弹出的是右操作数），执行运算，并将结果压回堆栈。
扫描完毕后，堆栈中剩下的唯一数字就是最终结果。

示例：计算 6 2 / 3 - 4 2 * +

输入	操作	操作数栈的状态 (栈底 -> 栈顶)
`6`	压栈	`[ 6 ]`
`2`	压栈	`[ 6, 2 ]`
`/`	弹出`2`和`6`，计算`6/2=3`，压栈	`[ 3 ]`
`3`	压栈	`[ 3, 3 ]`
`-`	弹出`3`和`3`，计算`3-3=0`，压栈	`[ 0 ]`
`4`	压栈	`[ 0, 4 ]`
`2`	压栈	`[ 0, 4, 2 ]`
`*`	弹出`2`和`4`，计算`4*2=8`，压栈	`[ 0, 8 ]`
`+`	弹出`8`和`0`，计算`0+8=8`，压栈	`[ 8 ]`
(结束)	结果为 8	`[ 8 ]`

2.4 实现细节：`++a` 与 `a++` 的辨析

在用C/C++等语言编程实现堆栈时，我们经常会用到递增/递减运算符，理解它们的区别至关重要。

++a (前置递增): 先加后用 —— 先将 a 的值加 1，然后使用 a 加 1 之后的新值作为表达式的结果。
a++ (后置递增): 先用后加 —— 先使用 a 当前未改变的原始值作为表达式的结果，然后再将 a 的值加 1。

关键点：无论哪种方式，该语句执行完后，a 本身的值都增加了1。区别仅在于它们作为表达式返回的值。在后续的堆栈代码实现中，我们会看到这些运算符的巧妙运用。

第三部分：堆栈的顺序存储实现（数组）

这是最直接的堆栈实现方式，通常由一个一维数组和一个记录栈顶位置的变量组成。

3.1 数据结构定义

#define MaxSize 100 // 定义堆栈的最大容量

typedef int ElementType; // 假设元素类型为整型

// 定义顺序栈的结构体
typedef struct SNode {
    ElementType Data[MaxSize]; // 存储数据的数组
    int Top;                  // 记录栈顶元素在数组中的下标
} *Stack;

约定：Top 指向栈顶元素的数组下标。当堆栈为空时，Top 初始化为 -1。

3.2 核心操作实现

入栈 (Push)

// 参数 Stack PtrS: 指向堆栈的指针
// 参数 ElementType item: 要入栈的元素
void Push(Stack PtrS, ElementType item) {
    // 检查堆栈是否已满
    if (PtrS->Top == MaxSize - 1) {
        printf("堆栈满");
        return;
    } else {
        // 核心操作：先将Top指针加1，再将元素存入该位置
        // ++(PtrS->Top) 是前置递增，确保Top先移动到新的空位
        PtrS->Data[++(PtrS->Top)] = item;
    }
}

出栈 (Pop)

// 参数 Stack PtrS: 指向堆栈的指针
ElementType Pop(Stack PtrS) {
    // 检查堆栈是否为空
    if (PtrS->Top == -1) {
        printf("堆栈空");
        return ERROR; // ERROR是一个预定义的错误标识
    } else {
        // 核心操作：先返回Top指针当前指向的元素，再将Top指针减1
        // (PtrS->Top)-- 是后置递减，确保先返回原始栈顶的值
        return PtrS->Data[(PtrS->Top)--];
    }
}

这一行代码巧妙地利用后置递减运算符，将“获取栈顶值”和“移动栈顶指针”两个任务合二为一。

3.3 应用：共享空间的双堆栈

为了最大化利用一个固定大小的数组，我们可以设计一个双堆栈结构：一个堆栈从数组头（下标0）向中间增长，另一个堆栈从数组尾（下标MaxSize-1）向中间增长。

数据结构：包含一个数组 Data，以及两个栈顶指针 Top1 和 Top2。
初始化：Top1 = -1，Top2 = MaxSize。
栈满条件：Top2 - Top1 == 1。
操作逻辑：
- Push到堆栈1：Data[++Top1] = item;
- Push到堆栈2：Data[--Top2] = item;
- Pop出堆栈1：return Data[Top1--];
- Pop出堆栈2：return Data[Top2++]; (注意是++，因为指针要向数组尾部移动)

这种设计极大提高了空间利用的灵活性。

第四部分：堆栈的链式存储实现（链表）

为了克服顺序栈容量固定的缺点，我们可以使用链表来实现一个可以动态增长的堆栈，称为链栈。

4.1 核心问题：栈顶在哪一端？

一个链栈本质上是一个单链表，插入和删除操作只能在栈顶进行。那么，栈顶应该设在链表的头部还是尾部？

选择头部作为栈顶（正确方案）
- Push：在链表头部插入新节点。时间复杂度 O(1)。
- Pop：删除链表的头节点。时间复杂度 O(1)。
- 结论：此方案极为高效。
选择尾部作为栈顶（错误方案）
- Push：在链表尾部插入新节点，需要遍历整个链表找到尾部。时间复杂度 O(n)。
- Pop：删除链表的尾节点，需要遍历整个链表找到倒数第二个节点。时间复杂度 O(n)。
- 结论：此方案效率低下，完全违背了堆栈操作应为O(1)的初衷。

因此，链栈的栈顶必须设置在单链表的头部。

4.2 数据结构与核心操作实现

// 链栈的节点定义
typedef struct SNode {
    ElementType Data;
    struct SNode *Next;
} *Stack; // 栈顶指针直接就是链表的头指针

// 入栈 (Push)
void Push(Stack *S, ElementType item) {
    // 1. 创建新节点
    Stack newNode = (Stack)malloc(sizeof(struct SNode));
    newNode->Data = item;
    // 2. 新节点指向原来的栈顶（旧头节点）
    newNode->Next = *S;
    // 3. 更新栈顶指针为新节点
    *S = newNode;
}

// 出栈 (Pop)
ElementType Pop(Stack *S) {
    if (*S == NULL) {
        printf("堆栈空");
        return ERROR;
    } else {
        // 1. 临时保存旧的栈顶
        Stack oldTop = *S;
        ElementType topData = oldTop->Data;
        // 2. 更新栈顶指针为下一个节点
        *S = oldTop->Next;
        // 3. 释放旧栈顶的内存
        free(oldTop);
        // 4. 返回数据
        return topData;
    }
}

第五部分：总结 —— 顺序栈 vs. 链栈

特性	顺序栈 (Array Stack)	链栈 (Linked Stack)
空间大小	固定，由 `MaxSize` 决定	动态，随需增减，受限于总内存
空间利用	可能存在空间浪费（分配得多用得少）	按需分配，空间利用率高
溢出问题	存在上溢 (Overflow)，即栈满	理论上不存在上溢
内存开销	紧凑，无额外开销	每个节点都有一个额外的指针域开销
核心操作效率	Push/Pop 均为 O(1)	Push/Pop 均为 O(1)