C语言实现栈与队列：数据结构基础与优化技巧

1. 栈与队列基础概念解析

在计算机科学中，栈和队列是两种最基本也最重要的线性数据结构。它们看似简单，却在系统设计、算法实现和底层开发中扮演着关键角色。我第一次真正理解它们的重要性，是在调试一个递归函数导致的内存溢出问题时——那时才深刻体会到栈空间的管理多么关键。

栈（Stack）遵循LIFO（Last In First Out）原则，就像我们日常叠放的盘子，最后放上去的总是最先被取用。这种特性使得栈在函数调用、表达式求值和括号匹配等场景中表现卓越。而队列（Queue）则遵循FIFO（First In First Out）原则，如同排队购票的队伍，先来的人先获得服务，这种特性天然适合任务调度、消息传递等场景。

2. C语言实现栈的底层设计

2.1 栈的结构定义

在C语言中，我们通常用结构体配合动态数组来实现栈。这种实现方式既保持了灵活性，又能很好地控制内存使用。以下是一个经典的栈结构定义：

c复制#define INIT_CAPACITY 4

typedef struct {
    int *items;     // 存储元素的数组
    int top;        // 栈顶指针
    int capacity;   // 当前分配的总容量
} Stack;

这里有几个关键设计点：

• 使用动态数组而非固定大小数组，避免空间浪费
• top指针初始化为-1，表示空栈状态
• 初始容量设为4，这是一个经验值，适合大多数小型应用场景

2.2 核心操作实现

2.2.1 初始化栈

c复制void stack_init(Stack *s) {
    s->items = (int*)malloc(INIT_CAPACITY * sizeof(int));
    if (s->items == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }
    s->top = -1;
    s->capacity = INIT_CAPACITY;
}

注意：这里必须检查malloc返回值，内存分配失败是嵌入式系统中常见的运行时错误。

2.2.2 入栈操作

c复制void stack_push(Stack *s, int value) {
    // 检查是否需要扩容
    if (s->top == s->capacity - 1) {
        resize_stack(s, s->capacity * 2);
    }
    s->items[++s->top] = value;
}

扩容函数的实现尤其需要注意内存管理：

c复制void resize_stack(Stack *s, int new_capacity) {
    int *new_items = realloc(s->items, new_capacity * sizeof(int));
    if (new_items == NULL) {
        fprintf(stderr, "Memory reallocation failed\n");
        exit(EXIT_FAILURE);
    }
    s->items = new_items;
    s->capacity = new_capacity;
}

2.2.3 出栈操作

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

重要技巧：在实际项目中，可以考虑返回操作状态而非直接退出程序，这能让调用者有机会处理异常。

3. 高级实现技巧与优化

3.1 内存管理策略

动态扩容虽然灵活，但也可能带来性能问题。一个优化的策略是：

1. 当空间不足时，按当前容量的1.5倍而非2倍扩容
2. 当栈大小长期低于容量的25%时，考虑缩容
3. 实现一个stack_shrink_to_fit()函数手动压缩内存

c复制void stack_shrink_to_fit(Stack *s) {
    if (s->top + 1 < s->capacity / 2) {
        resize_stack(s, max(INIT_CAPACITY, s->top + 1));
    }
}

3.2 多类型支持

通过void指针和元素大小参数，我们可以实现通用栈：

c复制typedef struct {
    void *items;    // 改为void指针
    size_t elem_size; // 元素大小
    int top;
    int capacity;
} GenericStack;

void generic_stack_push(GenericStack *s, const void *value) {
    // 计算写入位置
    void *target = (char*)s->items + (s->top + 1) * s->elem_size;
    memcpy(target, value, s->elem_size);
    s->top++;
}

这种实现虽然灵活，但会损失类型安全性，需要谨慎使用。

4. 栈与队列的对比实现

4.1 队列的数组实现

为了完整起见，我们来看下队列的环形缓冲区实现：

c复制typedef struct {
    int *items;
    int front;
    int rear;
    int size;
    int capacity;
} Queue;

void enqueue(Queue *q, int item) {
    if (q->size == q->capacity) {
        fprintf(stderr, "Queue overflow\n");
        return;
    }
    q->rear = (q->rear + 1) % q->capacity;
    q->items[q->rear] = item;
    q->size++;
}

环形队列的关键点在于取模运算实现下标循环，这避免了普通数组实现中数据搬移的开销。

4.2 性能对比

5. 实际应用案例分析

5.1 栈在表达式求值中的应用

一个经典案例是实现简单的算术表达式计算器。我们使用两个栈：一个存放操作数，一个存放运算符。

c复制int evaluate_expression(const char *expr) {
    Stack values;
    Stack ops;
    stack_init(&values);
    stack_init(&ops);

    for (int i = 0; expr[i]; i++) {
        if (expr[i] == ' ') continue;
        
        if (isdigit(expr[i])) {
            int num = 0;
            while (isdigit(expr[i])) {
                num = num * 10 + (expr[i] - '0');
                i++;
            }
            i--;
            stack_push(&values, num);
        }
        else if (expr[i] == '(') {
            stack_push(&ops, expr[i]);
        }
        // 其他操作符处理...
    }
    // ...后续处理
}

5.2 队列在消息传递中的应用

在嵌入式系统中，我们常用队列实现ISR（中断服务例程）与主程序间的通信：

c复制Queue msg_queue;

void ISR() {
    int data = read_sensor();
    enqueue(&msg_queue, data);
}

void main_loop() {
    while (1) {
        if (!queue_is_empty(&msg_queue)) {
            int data = dequeue(&msg_queue);
            process_data(data);
        }
        // 其他任务...
    }
}

这种设计避免了在ISR中进行复杂处理，符合嵌入式开发的最佳实践。

6. 常见问题与调试技巧

6.1 栈溢出问题

这是实现递归算法时最常见的问题。有一次我实现二叉树遍历时遇到了这样的错误：

code复制Stack overflow: reached maximum call stack size

解决方案：

1. 将递归算法改为迭代实现
2. 增加栈空间大小（如果环境允许）
3. 使用尾递归优化（如果编译器支持）

6.2 内存泄漏检测

对于动态分配的栈，内存泄漏是另一个常见问题。我习惯在调试时添加这样的检查代码：

c复制void stack_destroy(Stack *s) {
    free(s->items);
    // 标记已释放状态
    s->items = NULL;
    s->top = -2;
    s->capacity = 0;
}

然后在各个函数开头添加状态检查：

c复制assert(s->top != -2 && "Using destroyed stack");

6.3 多线程环境下的安全

如果栈需要在多线程环境中使用，简单的实现会导致竞争条件。这时需要引入同步机制：

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

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

但要注意锁的粒度——过于频繁的加锁会严重影响性能。