从零实现栈结构：原理、C语言实现与应用场景

1. 为什么需要手写栈结构？

在编程面试和算法竞赛中，栈（Stack）是最基础也最常被考察的数据结构之一。虽然现代编程语言的标准库都提供了现成的栈实现（比如C++的stack、Java的Stack类、Python的list），但真正理解栈的底层原理，能够从零开始实现一个完整的栈结构，仍然是每个合格程序员的基本功。

我见过太多候选人，在被要求"不用标准库，自己实现一个栈"时手足无措。他们可能熟练使用stack.push()和stack.pop()，却说不清当push一个元素时内存发生了什么变化，或者当pop一个空栈时应该如何处理异常。这正是我们需要"手撕"栈结构的原因——只有亲手实现过，才能对以下核心概念有深刻理解：

• LIFO（后进先出）原则：最后一个入栈的元素总是第一个出栈，这个特性如何通过代码体现？
• 栈顶指针：如何用一个简单的整型变量追踪当前栈顶位置？
• 动态扩容：当栈空间不足时，如何优雅地扩展容量而不丢失已有数据？
• 边界检查：如何处理栈空时的pop操作和栈满时的push操作？

2. 栈的底层实现方式选择

实现栈的底层数据结构主要有两种选择：数组（静态/动态）和链表。我们先对比它们的特性：

对于大多数场景，动态数组是实现栈的最佳选择，原因如下：

1. 现代CPU的缓存预取机制对连续内存访问更高效
2. 实际应用中栈操作集中在尾部，数组的O(1)访问优势明显
3. 虽然扩容时需要数据拷贝，但采用倍增策略可使均摊时间复杂度仍为O(1)

提示：在内存受限的嵌入式系统中，静态数组（固定大小）可能是更好的选择，因为它避免了动态内存分配的开销。

3. C语言实现动态栈

下面我们用C语言实现一个支持动态扩容的栈。选择C语言是因为它足够底层，能清晰展示内存管理的细节，这些细节在高级语言中往往被隐藏。

3.1 结构体定义与初始化

c复制#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct {
    int *items;     // 存储栈元素的数组
    int top;        // 栈顶指针（实际上是数组索引）
    int capacity;   // 当前栈的容量
} Stack;

void initStack(Stack *s, int initialCapacity) {
    s->items = (int *)malloc(initialCapacity * sizeof(int));
    if (s->items == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }
    s->top = -1;    // -1表示空栈
    s->capacity = initialCapacity;
}

关键点解析：

• top初始化为-1是行业惯例，这样第一个元素入栈后top变为0，与数组索引一致
• 分配内存后必须检查malloc是否成功，这是C语言编程的好习惯
• capacity记录当前数组大小，为后续扩容做准备

3.2 核心操作实现

3.2.1 push操作与动态扩容

c复制void push(Stack *s, int value) {
    // 检查是否需要扩容
    if (s->top == s->capacity - 1) {
        int newCapacity = s->capacity * 2;  // 常见的倍增策略
        int *newItems = (int *)realloc(s->items, newCapacity * sizeof(int));
        if (newItems == NULL) {
            fprintf(stderr, "Memory reallocation failed\n");
            exit(EXIT_FAILURE);
        }
        s->items = newItems;
        s->capacity = newCapacity;
        printf("Stack resized to %d\n", newCapacity);
    }
    
    s->items[++s->top] = value;  // 先移动top指针，再存储值
}

扩容策略说明：

• 当栈满（top == capacity - 1）时，容量倍增（而非固定增量）确保均摊时间复杂度为O(1)
• 使用realloc而非malloc+memcpy组合，因为realloc可能原地扩展内存，效率更高
• 即使倍增，也要检查分配是否成功，这是很多初学者容易忽略的

3.2.2 pop操作与边界检查

c复制int pop(Stack *s) {
    if (isEmpty(s)) {
        fprintf(stderr, "Stack underflow\n");
        exit(EXIT_FAILURE);
    }
    return s->items[s->top--];  // 先返回值，再移动top指针
}

bool isEmpty(Stack *s) {
    return s->top == -1;
}

错误处理要点：

• 对空栈执行pop称为"栈下溢（stack underflow）"，必须明确处理
• 生产环境中可能更适合返回错误码或使用异常，而非直接退出程序
• top--实现了LIFO原则：最后入栈的元素最先被弹出

3.3 完整示例与测试

c复制int peek(Stack *s) {
    if (isEmpty(s)) {
        fprintf(stderr, "Stack is empty\n");
        exit(EXIT_FAILURE);
    }
    return s->items[s->top];
}

void freeStack(Stack *s) {
    free(s->items);
    s->items = NULL;
    s->top = -1;
    s->capacity = 0;
}

int main() {
    Stack s;
    initStack(&s, 2);  // 初始容量设为2测试扩容
    
    push(&s, 10);
    push(&s, 20);
    printf("Top element: %d\n", peek(&s));  // 应输出20
    
    push(&s, 30);  // 触发扩容
    printf("Stack capacity: %d\n", s.capacity);  // 应输出4
    
    printf("Popped: %d\n", pop(&s));  // 30
    printf("Popped: %d\n", pop(&s));  // 20
    printf("Stack empty? %s\n", isEmpty(&s) ? "Yes" : "No");  // No
    
    freeStack(&s);
    return 0;
}

实测输出：

code复制Top element: 20
Stack resized to 4
Stack capacity: 4
Popped: 30
Popped: 20
Stack empty? No

4. 栈的经典应用场景

理解了栈的实现原理后，我们来看几个实际应用，这些场景在面试中经常被要求用栈解决：

4.1 括号匹配检查

编译器需要检查源代码中的括号是否匹配，栈是完美的解决方案：

c复制bool isBalanced(const char *expr) {
    Stack s;
    initStack(&s, strlen(expr));
    
    for (int i = 0; expr[i]; i++) {
        if (expr[i] == '(' || expr[i] == '[' || expr[i] == '{') {
            push(&s, expr[i]);
        } else if (expr[i] == ')' || expr[i] == ']' || expr[i] == '}') {
            if (isEmpty(&s)) return false;
            
            char topChar = pop(&s);
            if ((expr[i] == ')' && topChar != '(') ||
                (expr[i] == ']' && topChar != '[') ||
                (expr[i] == '}' && topChar != '{')) {
                freeStack(&s);
                return false;
            }
        }
    }
    
    bool result = isEmpty(&s);
    freeStack(&s);
    return result;
}

4.2 函数调用栈

计算机底层正是用栈管理函数调用的：

1. 调用函数时，返回地址、参数和局部变量被压入调用栈
2. 函数执行结束时，这些数据被弹出，CPU回到返回地址继续执行
3. 递归调用过深导致的"栈溢出"就是因为调用栈空间耗尽

4.3 浏览器前进后退

浏览器用两个栈实现页面导航：

• 栈A记录已访问页面
• 点击后退时，从栈A弹出并压入栈B
• 点击前进时，从栈B弹出并压入栈A

5. 实现中的常见陷阱与优化

5.1 内存管理陷阱

1. 忘记释放内存：每个malloc/realloc必须对应一个free

   c复制// 错误示例：只free了栈结构体，没free内部的items数组
   void badFree(Stack *s) {
       free(s);  // 只释放了结构体本身！
   }
   
   // 正确做法
   void goodFree(Stack *s) {
       free(s->items);
       free(s);
   }
   

2. 野指针问题：释放内存后应将指针置NULL

   c复制s->items = NULL;  // 防止后续误用
   

5.2 性能优化技巧

1. 批量操作接口：减少函数调用开销

   c复制void pushMultiple(Stack *s, const int *values, int count) {
       // 先检查是否需要扩容
       while (s->top + count >= s->capacity) {
           // 扩容逻辑...
       }
       
       memcpy(&s->items[s->top + 1], values, count * sizeof(int));
       s->top += count;
   }
   

2. 缩小容量：当栈空间利用率长期较低时，可释放多余内存

   c复制void shrinkToFit(Stack *s) {
       if (s->top + 1 < s->capacity / 2) {
           int newCapacity = s->capacity / 2;
           int *newItems = realloc(s->items, newCapacity * sizeof(int));
           if (newItems) {
               s->items = newItems;
               s->capacity = newCapacity;
           }
       }
   }
   

5.3 线程安全考虑

在多线程环境下使用栈需要同步机制。最简单的方案是用互斥锁保护所有操作：

c复制#include <pthread.h>

typedef struct {
    int *items;
    int top;
    int capacity;
    pthread_mutex_t lock;
} ThreadSafeStack;

void tsInit(ThreadSafeStack *s, int capacity) {
    s->items = malloc(capacity * sizeof(int));
    s->top = -1;
    s->capacity = capacity;
    pthread_mutex_init(&s->lock, NULL);
}

void tsPush(ThreadSafeStack *s, int value) {
    pthread_mutex_lock(&s->lock);
    // 正常的push逻辑...
    pthread_mutex_unlock(&s->lock);
}

// 其他操作类似...

6. 不同语言实现对比

虽然栈的原理相同，但不同语言的实现各有特点：

6.1 Python实现

利用列表的append和pop方法，Python实现极其简洁：

python复制class Stack:
    def __init__(self):
        self.items = []
    
    def push(self, item):
        self.items.append(item)  # 自动处理扩容
    
    def pop(self):
        if not self.is_empty():
            return self.items.pop()
        raise IndexError("pop from empty stack")
    
    def peek(self):
        return self.items[-1] if not self.is_empty() else None
    
    def is_empty(self):
        return len(self.items) == 0
    
    def size(self):
        return len(self.items)

Python列表本身就是动态数组，因此无需手动管理内存。但要注意：

• pop()空列表会抛出IndexError，需要捕获或提前检查
• 列表的append和pop操作都是O(1)时间复杂度

6.2 Java实现

Java的Stack类实际继承自Vector，由于历史原因存在设计问题。现代Java推荐使用Deque接口：

java复制import java.util.ArrayDeque;
import java.util.Deque;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> stack = new ArrayDeque<>();
        stack.push(10);  // 入栈
        stack.push(20);
        
        System.out.println(stack.peek());  // 20
        System.out.println(stack.pop());   // 20
        System.out.println(stack.isEmpty()); // false
    }
}

关键区别：

• ArrayDeque基于循环数组，比Stack类性能更好
• Java标准库的栈操作在空栈时抛出EmptyStackException
• 泛型机制确保类型安全，避免C语言中的类型转换问题

6.3 C++ STL实现

C++的std::stack是容器适配器，默认基于std::deque：

cpp复制#include <iostream>
#include <stack>

int main() {
    std::stack<int> s;
    s.push(10);
    s.push(20);
    
    std::cout << "Top: " << s.top() << std::endl;  // 20
    s.pop();
    
    if (!s.empty()) {
        std::cout << "Size: " << s.size() << std::endl;  // 1
    }
}

特点：

• 可以选择底层容器（deque/list/vector）
• pop()不返回元素，需先调用top()
• 模板机制提供类型安全

7. 进阶话题：栈与递归的关系

所有递归算法都可以用栈改写为非递归形式，这是理解栈的重要进阶内容。以经典的阶乘函数为例：

递归版本：

c复制int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

用栈改写的非递归版本：

c复制int factorialIterative(int n) {
    Stack s;
    initStack(&s, 10);
    
    // 模拟递归调用栈
    while (n > 1) {
        push(&s, n);
        n--;
    }
    
    int result = 1;
    while (!isEmpty(&s)) {
        result *= pop(&s);
    }
    
    freeStack(&s);
    return result;
}

这种转换揭示了递归的本质：

1. 每次递归调用相当于将当前状态压栈
2. 每次返回相当于从栈中恢复之前的状态
3. 栈深度决定了递归的最大深度

在二叉树遍历、DFS等算法中，这种转换技巧尤为重要。当递归深度可能导致栈溢出时（如处理超大数据集），用显式栈的非递归算法是更安全的选择。