C语言链栈实现详解：从指针操作到共享栈应用

链栈C语言实现数据结构

于 2026-09-01 04:20:25 修改

·本内容遵循CC 4.0 BY-SA版权协议

最近在辅导几位刚入门数据结构的同学时，发现大家对“栈”这个基础概念理解得很快，但一到代码实现，尤其是链式存储的“链栈”，就容易在指针操作和边界条件上犯迷糊。初始化时指针没置空、入栈出栈顺序搞反、忘记判断栈空栈满……这些看似微小的疏忽，却足以让程序崩溃。本文将从零开始，手把手带你用C语言实现链栈，并深入探讨一个高级话题——共享栈。我们不仅会写出每一行可运行的代码，更会剖析每一步“为什么这么做”，帮你建立清晰的指针思维和错误处理意识。无论你是正在备战期末考试，还是希望夯实算法基础，这篇文章都能让你对栈的理解从“知道”跃升到“掌握”。

1. 栈与链栈：核心概念扫盲

在开始写代码之前，我们必须先统一思想，理解我们要实现的到底是什么。

1.1 栈是什么？它解决什么问题？

你可以把栈想象成一个只有一个开口的羽毛球筒。你只能从筒的顶部放入（压入）或取出（弹出）羽毛球，而不能从中间或底部操作。这种“后进先出”（Last In, First Out, LIFO）的特性，就是栈的核心。

栈在计算机科学中无处不在：

函数调用：系统使用“调用栈”来记录函数的调用顺序和局部变量。当函数A调用函数B时，A的现场被压入栈；B执行完毕后弹出，程序回到A继续执行。
表达式求值：编译器利用栈来处理运算符的优先级，例如将中缀表达式 3 + 4 * 2 转换为后缀表达式 3 4 2 * + 再进行计算。
括号匹配：检查代码中的括号 {}, (), [] 是否成对出现，是栈的经典应用。
浏览器的前进后退：你访问的页面URL被压入一个栈，后退操作就是从这个栈中弹出最近的页面。

栈的基本操作通常被抽象为以下几个：

InitStack(&S)：初始化一个空栈S。
Push(&S, x)：将元素x压入栈顶。
Pop(&S, &x)：删除栈顶元素，并用x返回其值。
GetTop(S, &x)：获取栈顶元素的值，但不删除它。
StackEmpty(S)：判断栈是否为空。

1.2 链栈 vs. 顺序栈：如何选择？

栈的存储结构主要有两种：顺序栈和链栈。

顺序栈：使用数组实现。就像给羽毛球筒预先划定一个固定大小的空间。优点是实现简单、存取速度快。缺点在于容量固定，可能存在“栈满”的情况，且扩容成本高（通常需要复制整个数组）。
链栈：使用链表实现。每个羽毛球（元素）都自带一个小挂钩（指针），指向它下面的那个羽毛球。这样，栈就由一系列通过指针链接的节点组成。链栈的栈顶就是链表的头节点。

为什么选择链栈？

动态扩容：理论上，只要内存足够，链栈可以无限增长，不存在“栈满”问题（除非内存耗尽）。这在实际应用中非常灵活。
内存利用高效：不需要像顺序栈那样预先分配一大块可能用不完的空间，内存按需分配。
理解指针和链表的绝佳实践：实现链栈能让你深刻理解指针操作、动态内存管理以及链表结构，这是学习数据结构的重要一环。

链栈的“栈满”判断：对于链栈，我们通常认为它不会满（除非malloc失败）。但在严谨的实现和教学讨论中，我们仍会探讨“栈满”的概念，它通常指动态申请内存失败。

1.3 共享栈：一个空间，两种用法

共享栈是顺序栈的一种巧妙应用，它利用一个数组的两端分别作为两个栈的栈底，两个栈的栈顶向中间增长。这样可以更有效地利用数组空间，减少空间浪费。虽然本文标题提到了共享栈，但其核心实现基于数组。为了内容的连贯性，我们将在实现链栈后，专门用一节来讲解共享栈的数组实现，这有助于你对比理解不同存储结构的优劣。

2. 开发环境与准备工作

在开始编码前，请确保你的环境已就绪。

编程语言：C语言。本文所有代码均使用标准C语法。
编译器：任何支持C99及以上标准的编译器均可，如 GCC (MinGW)、Clang 或 Visual Studio 中的 MSVC。
集成开发环境（IDE）：推荐使用 Visual Studio Code、Code::Blocks、Dev-C++ 或 CLion。使用简单的文本编辑器（如 Notepad++）配合命令行编译也可以。
基础要求：你需要对C语言有基本了解，包括指针、结构体、动态内存分配（malloc, free）和函数的使用。

示例项目结构：我们将创建一个简单的程序，包含链栈的实现和测试。

TEXT

linked_stack/

├── linked_stack.c // 链栈的实现与主函数

└── linked_stack.h // 链栈的结构定义和函数声明（可选，对于小项目可以合并）

对于初学者，我们可以将所有代码放在一个 .c 文件中，简化流程。

3. 链栈的详细设计与实现

接下来，我们进入核心部分。我们将一步步定义链栈的结构，并实现所有基本操作。

3.1 定义链栈节点结构

链栈的每个元素都是一个“节点”。每个节点需要存储两部分信息：

数据域：存放我们想要存储的实际数据（例如一个整数、一个字符等）。
指针域：存放指向下一个节点的指针。对于栈来说，就是指向它“下面”那个节点的指针。

在C语言中，我们用结构体来定义这个节点。

// 定义链栈的节点结构

typedef struct StackNode {

int data; // 数据域，这里以整型为例

struct StackNode *next; // 指针域，指向下一个节点

} StackNode;

typedef 关键字为我们创建的新类型起了个别名 StackNode，这样后面声明变量时就不用写 struct StackNode 了。
*next 是一个指向 StackNode 类型的指针。它就像那个“小挂钩”，将当前节点和下一个节点连接起来。

那么，什么是“链栈”本身呢？链栈只需要一个指针，始终指向栈顶节点即可。我们通常用一个额外的结构体来管理这个栈顶指针，这样更清晰。

// 定义链栈结构（管理栈顶指针）

typedef struct LinkedStack {

StackNode *top; // 栈顶指针

int size; // 栈中当前元素个数（可选，方便查询）

} LinkedStack;

*top：这是链栈的灵魂。当栈为空时，top 指向 NULL。当有元素时，top 指向最新入栈的那个节点。
size：这是一个非常实用的辅助字段。有了它，我们可以用 O(1) 的时间复杂度获取栈的长度，而无需遍历整个链表。它不是必须的，但强烈推荐。

3.2 初始化链栈

初始化操作的目标是创建一个空的链栈。对于我们的 LinkedStack 结构，这意味着将 top 指针设为 NULL，并将 size 设为 0。

/**

* 初始化链栈

* @param S 指向链栈的指针的指针（为了修改外部传入的栈）

* @return 初始化成功返回1，失败返回0

int InitStack(LinkedStack **S) {

// 1. 为链栈结构体分配内存

*S = (LinkedStack *)malloc(sizeof(LinkedStack));

if (*S == NULL) {

printf("内存分配失败！\n");

return 0; // 初始化失败

}

// 2. 设置栈顶指针为空，大小为0

(*S)->top = NULL;

(*S)->size = 0;

printf("链栈初始化成功。\n");

return 1; // 初始化成功

}

关键点解释：

LinkedStack **S：我们传入的是 LinkedStack 指针的地址（即二级指针）。因为我们需要在函数内部修改外部的 LinkedStack * 指针，使其指向新分配的内存。如果只传一级指针，修改的只是副本，外部指针不会改变。
malloc(sizeof(LinkedStack))：为管理结构 LinkedStack 申请内存。注意，这里申请的是 LinkedStack 的空间，而不是 StackNode。LinkedStack 只包含一个指针和一个整数，非常小。
(*S)->top = NULL：这是至关重要的一步。将栈顶指针明确置为 NULL，是判断栈空的唯一可靠依据。忘记这一步会导致后续判断逻辑错误。
返回值：通过返回值告知调用者初始化是否成功，这是良好的编程习惯。

3.3 判断栈空

栈空的条件非常简单：栈顶指针 top 是否为 NULL。

/**

* 判断链栈是否为空

* @param S 链栈指针

* @return 栈空返回1，非空返回0

int StackEmpty(LinkedStack *S) {

// 如果栈不存在，也认为是空（或返回错误）

if (S == NULL) {

return 1;

}

return S->top == NULL; // 核心判断

// 或者使用辅助的 size 字段： return S->size == 0;

}

3.4 入栈操作

入栈（Push）就是在链表头部插入一个新节点。这是链栈的优势所在，时间复杂度为 O(1)。

/**

* 入栈操作

* @param S 链栈指针

* @param e 要入栈的元素值

* @return 入栈成功返回1，失败返回0

int Push(LinkedStack *S, int e) {

// 1. 参数检查

if (S == NULL) {

printf("栈未初始化！\n");

return 0;

}

// 2. 为新的栈顶节点分配内存

StackNode *newNode = (StackNode *)malloc(sizeof(StackNode));

if (newNode == NULL) {

printf("内存分配失败，无法入栈！\n");

return 0; // 这可以看作是链栈的“栈满”情况

}

// 3. 填充新节点的数据

newNode->data = e;

// 4. 将新节点插入到链表头部（栈顶）

newNode->next = S->top; // 新节点指向原栈顶

S->top = newNode; // 栈顶指针更新为新节点

// 5. 更新栈大小

S->size++;

printf("元素 %d 入栈成功。\n", e);

return 1;

}

图解与思考：假设现有栈顶节点存储数据 10，top 指向它。现在要入栈元素 20。

创建新节点 newNode，其 data=20。
执行 newNode->next = S->top;。此时 newNode->next 指向了存储 10 的节点。
执行 S->top = newNode;。栈顶指针 top 改为指向新节点 newNode。
最终，栈顶是 20，其 next 指向 10，形成了正确的链式结构。

为什么在头部插入？ 因为在链表头部插入和删除节点是效率最高的操作（O(1)），这完美契合了栈顶操作频繁的特性。

3.5 出栈操作

出栈（Pop）就是删除链表头部的节点，并返回其值。同样也是 O(1) 的时间复杂度。

/**

* 出栈操作

* @param S 链栈指针

* @param e 用来接收出栈元素的指针

* @return 出栈成功返回1，失败返回0

int Pop(LinkedStack *S, int *e) {

// 1. 参数检查

if (S == NULL || e == NULL) {

printf("参数错误！\n");

return 0;

}

// 2. 检查栈是否为空

if (StackEmpty(S)) {

printf("栈为空，无法出栈！\n");

return 0;

}

// 3. 获取栈顶节点及其数据

StackNode *topNode = S->top; // topNode 指向要删除的节点

*e = topNode->data; // 通过指针e将数据传回给调用者

// 4. 更新栈顶指针

S->top = topNode->next; // 栈顶指针指向原栈顶的下一个节点

// 5. 释放原栈顶节点的内存

free(topNode);

// 6. 更新栈大小

S->size--;

printf("元素 %d 出栈成功。\n", *e);

return 1;

}

关键点与易错点：

顺序不能错：必须先通过 topNode 保存原栈顶节点的地址，然后再更新 S->top。如果先 S->top = S->top->next;，就丢失了原栈顶节点的地址，无法释放其内存，导致内存泄漏。
内存释放：free(topNode) 是必须的。链栈动态申请了内存，不用时必须释放，否则会造成内存泄漏。
返回数据：通过指针参数 *e 将出栈元素的值返回给调用者，这是C语言中函数返回多个值的常用方法。

3.6 获取栈顶元素

获取栈顶元素（GetTop/Peek）与出栈类似，但不删除节点。

/**

* 获取栈顶元素

* @param S 链栈指针

* @param e 用来接收栈顶元素的指针

* @return 获取成功返回1，失败返回0

int GetTop(LinkedStack *S, int *e) {

if (S == NULL || e == NULL || StackEmpty(S)) {

printf("栈为空或参数错误，无法获取栈顶！\n");

return 0;

}

*e = S->top->data; // 直接读取栈顶节点的数据

return 1;

}

3.7 销毁链栈

由于链栈的节点是动态分配的，当整个栈不再使用时，必须遍历所有节点并逐一释放，最后释放管理结构 LinkedStack 本身，防止内存泄漏。

/**

* 销毁链栈，释放所有内存

* @param S 指向链栈的指针的指针

void DestroyStack(LinkedStack **S) {

if (S == NULL || *S == NULL) {

return;

}

LinkedStack *stack = *S;

int poppedValue;

// 循环出栈，直到栈空，释放所有节点内存

while (!StackEmpty(stack)) {

Pop(stack, &poppedValue); // Pop函数内部会free节点

}

// 所有节点释放完毕后，释放链栈管理结构本身

free(stack);

*S = NULL; // 将外部指针置为NULL，避免成为野指针

printf("链栈已销毁，所有内存已释放。\n");

}

4. 链栈的完整实战案例

现在，让我们将所有代码组合起来，写一个完整的测试程序。

# include <stdio.h>

# include <stdlib.h> // 包含 malloc 和 free 函数

// -------- 此处插入前面章节的所有结构体定义和函数实现代码 --------

// (为了节省篇幅，这里省略重复代码。实际编写时应将3.1至3.7的代码放在这里)

int main() {

LinkedStack *myStack = NULL; // 声明一个链栈指针

int value;

printf("=== 链栈操作测试 ===\n\n");

// 1. 初始化

if (!InitStack(&myStack)) {

printf("程序初始化失败，退出。\n");

return -1;

}

// 2. 判断栈空

printf("当前栈是否为空？ %s\n\n", StackEmpty(myStack) ? "是" : "否");

// 3. 入栈一系列元素

printf("执行入栈操作：\n");

for (int i = 1; i <= 5; i++) {

Push(myStack, i * 10); // 入栈 10, 20, 30, 40, 50

}

printf("\n");

// 4. 获取栈顶元素

if (GetTop(myStack, &value)) {

printf("当前栈顶元素是：%d\n", value);

}

printf("当前栈大小：%d\n\n", myStack->size);

// 5. 出栈两次并打印

printf("执行两次出栈操作：\n");

Pop(myStack, &value);

printf("第一次出栈：%d\n", value);

Pop(myStack, &value);

printf("第二次出栈：%d\n", value);

printf("出栈后栈大小：%d\n\n", myStack->size);

// 6. 再次获取栈顶

if (GetTop(myStack, &value)) {

printf("当前栈顶元素是：%d\n", value);

}

// 7. 将剩余元素全部出栈

printf("\n清空栈：\n");

while (!StackEmpty(myStack)) {

Pop(myStack, &value);

printf("出栈：%d\n", value);

}

printf("栈是否已空？ %s\n\n", StackEmpty(myStack) ? "是" : "否");

// 8. 尝试对空栈出栈（应该失败）

printf("尝试对空栈出栈：\n");

if (!Pop(myStack, &value)) {

printf("出栈失败，符合预期。\n");

}

// 9. 销毁栈

DestroyStack(&myStack);

return 0;

}

运行与验证：将上述所有代码（包括结构体定义和函数实现）保存到一个文件，例如 linked_stack_demo.c，然后使用编译器编译运行。

预期输出：

TEXT

=== 链栈操作测试 ===

链栈初始化成功。

当前栈是否为空？是

执行入栈操作：

元素 10 入栈成功。

元素 20 入栈成功。

元素 30 入栈成功。

元素 40 入栈成功。

元素 50 入栈成功。

当前栈顶元素是：50

当前栈大小：5

执行两次出栈操作：

元素 50 出栈成功。

第一次出栈：50

元素 40 出栈成功。

第二次出栈：40

出栈后栈大小：3

当前栈顶元素是：30

清空栈：

元素 30 出栈成功。

出栈：30

元素 20 出栈成功。

出栈：20

元素 10 出栈成功。

出栈：10

栈是否已空？是

尝试对空栈出栈：

栈为空，无法出栈！

出栈失败，符合预期。

链栈已销毁，所有内存已释放。

通过这个输出，你可以清晰地看到栈“后进先出”的特性：最后入栈的 50 最先出栈。同时，所有内存管理操作（初始化、销毁）都得到了正确执行。

5. 共享栈的概念与数组实现

理解了链栈，我们再来看看共享栈。共享栈是顺序栈的一种高效变体，它使用一个数组来同时实现两个栈。

5.1 共享栈的设计思想

想象一个长长的数组。普通的顺序栈只使用数组的一端（通常是下标为0的一端）作为栈底。共享栈则让两个栈共享这个数组空间：

栈0：栈底在数组的起始位置（0），栈顶指针 top0 初始为 -1，向数组尾部增长（++top0）。
栈1：栈底在数组的末尾（MAX_SIZE - 1），栈顶指针 top1 初始为 MAX_SIZE，向数组头部增长（--top1）。

这样，两个栈的栈顶相向而行，只有当 top0 + 1 == top1 时，才意味着数组空间被耗尽，共享栈“满”。这极大地提高了数组空间的利用率。

5.2 共享栈的结构定义与初始化

# define MAX_SIZE 100 // 共享栈的最大容量

typedef struct SharedStack {

int data[MAX_SIZE]; // 存储元素的数组

int top0; // 栈0的栈顶指针

int top1; // 栈1的栈顶指针

} SharedStack;

// 初始化共享栈

void InitSharedStack(SharedStack *S) {

S->top0 = -1; // 栈0为空

S->top1 = MAX_SIZE; // 栈1为空

}

5.3 共享栈的入栈与出栈

// 向栈0入栈

int Push0(SharedStack *S, int x) {

if (S->top0 + 1 == S->top1) { // 栈满判断

printf("共享栈已满！\n");

return 0;

}

S->data[++(S->top0)] = x; // top0先加1，再赋值

return 1;

}

// 从栈0出栈

int Pop0(SharedStack *S, int *x) {

if (S->top0 == -1) { // 栈0空判断

printf("栈0为空！\n");

return 0;

}

*x = S->data[(S->top0)--]; // 先取值，top0再减1

return 1;

}

// 向栈1入栈

int Push1(SharedStack *S, int x) {

if (S->top1 - 1 == S->top0) { // 栈满判断

printf("共享栈已满！\n");

return 0;

}

S->data[--(S->top1)] = x; // top1先减1，再赋值

return 1;

}

// 从栈1出栈

int Pop1(SharedStack *S, int *x) {

if (S->top1 == MAX_SIZE) { // 栈1空判断

printf("栈1为空！\n");

return 0;

}

*x = S->data[(S->top1)++]; // 先取值，top1再加1

return 1;

}

要点：注意栈0和栈1的栈顶指针移动方向是相反的。栈满的条件是两个栈顶指针相邻。

6. 常见问题与排查思路

在实现和使用链栈时，新手常会遇到以下几个问题：

问题现象	可能原因	排查与解决思路
程序崩溃（Segmentation Fault）	1. 访问了 `NULL` 指针（如空栈时执行 `S->top->data`）。 2. 使用了已释放的内存（`free` 后再次访问）。 3. 指针未初始化（野指针）。	1. 在所有函数入口检查指针参数是否为 `NULL`。 2. 在 `Pop`、`GetTop` 等操作前，务必调用 `StackEmpty` 检查栈空。 3. 初始化时将指针显式置为 `NULL`（如 `InitStack` 中 `(*S)->top = NULL`）。 4. 使用调试器（如GDB）定位崩溃行。
内存泄漏	只 `malloc`，不 `free`。例如，`Pop` 操作只移动了 `top` 指针，没有释放原栈顶节点。	1. 确保每个 `malloc` 都有对应的 `free`。在 `Pop` 和 `DestroyStack` 中正确释放节点内存。 2. 可以使用工具如 `valgrind` 来检测内存泄漏。
逻辑错误，数据不对	1. 入栈/出栈时指针操作顺序错误。 2. 更新了 `top` 指针，但忘记更新 `size`。 3. 共享栈的栈满条件判断错误。	1. 画图辅助理解。在纸上画出节点和指针，模拟操作步骤。 2. 添加打印语句，在关键步骤后打印 `top` 指针和 `size` 的值。 3. 进行单元测试，用不同的测试用例（空栈、单元素、多元素）验证每个函数。
“栈满”判断困惑	对于链栈，理论上不会满，但 `malloc` 可能失败。	在 `Push` 函数中，检查 `malloc` 的返回值。如果为 `NULL`，则按“栈满”处理，返回失败。

7. 最佳实践与工程建议

将链栈从课堂练习应用到实际项目，需要注意更多细节。

通用性设计：
- 本文示例使用 int 作为数据域。在实际项目中，应使用 typedef 来定义栈的元素类型，方便修改。
C

typedef int ElemType; // 需要时，只需修改这一行

typedef struct StackNode {

ElemType data;

struct StackNode *next;

} StackNode;
错误处理强化：
- 不要仅仅 printf 错误信息。在库函数中，应通过返回值或设置全局错误码来通知调用者。
- 考虑使用枚举定义更丰富的错误类型。
C

typedef enum {

STACK_OK,

STACK_ERROR_NULL_PTR,

STACK_ERROR_MALLOC_FAIL,

STACK_ERROR_EMPTY,

STACK_ERROR_FULL

} StackStatus;
多线程安全：
- 如果栈会在多线程环境下使用，基本的链栈实现不是线程安全的。Push 和 Pop 操作可能被中断，导致链表断裂。此时需要引入互斥锁（mutex）来保护临界区。
性能考量：
- 链栈：每次 Push 都需要 malloc，每次 Pop 都需要 free。频繁的堆内存操作可能带来性能开销和内存碎片。适用于元素数量变化大、难以预估最大容量的场景。
- 顺序栈/共享栈：内存连续，访问速度快，没有内存分配开销。但容量固定。适用于能明确预估最大容量或对性能要求极高的场景。
选择建议：
- 学习与理解数据结构：强烈推荐实现链栈。它能让你彻底掌握指针和动态内存管理。
- 嵌入式或对性能有严格要求的系统：优先考虑顺序栈或共享栈，避免动态内存管理的不可预测性。
- 需要存储复杂或大型对象：考虑链栈，因为移动指针的成本远低于在数组中移动大量数据。
- 两个栈的增长和收缩正好相反：使用共享栈可以高效利用内存。

通过本文，我们从栈的基本概念出发，详细实现了链栈的每一个操作，并探讨了其变体共享栈。关键在于理解指针的指向和内存的生命周期管理。自己动手将代码敲一遍，用调试器跟踪指针的变化，遇到问题对照第六节的排查思路解决，你对链栈的理解一定会非常牢固。数据结构的学习没有捷径，多思考、多画图、多实践，是掌握它的不二法门。