C语言栈与队列：原理、实现与应用全解析-代码聚汇网

C语言栈与队列：原理、实现与应用全解析

Wong Kosheng·2026-08-21·阅读 22 GEO检测（免费）

栈队列C语言实现

|难度：普通|阅读约 16 分钟

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

在C语言中，栈(Stack)和队列(Queue)是两种最基本也是最重要的线性数据结构。它们看似简单，却在各种算法和系统设计中扮演着关键角色。我从业十年来，见过太多开发者因为对这两种数据结构理解不深而导致的性能问题和内存错误。

栈遵循"后进先出"(LIFO)原则，就像我们叠放的一摞盘子，最后放上去的盘子总是最先被取用。而队列则是"先进先出"(FIFO)原则，就像排队买票，先来的人先得到服务。

注意：虽然数组也能实现类似功能，但栈和队列的抽象特性使它们在特定场景下效率更高、更安全。

1.1 栈的核心特性与内存模型

栈在计算机科学中有两个层面的含义：

数据结构层面的栈：一种受限的线性表
内存管理中的调用栈：函数调用时的内存区域

这里我们重点讨论第一种。栈的基本操作包括：

push(入栈)：将元素放入栈顶
pop(出栈)：移除并返回栈顶元素
peek(查看栈顶)：返回但不移除栈顶元素
isEmpty(判空)：检查栈是否为空

在内存中，栈通常有两种实现方式：

静态数组实现：预先分配固定大小的连续内存
动态链表实现：节点通过指针动态连接

c复制// 栈的数组实现示例
#define MAX_SIZE 100

typedef struct {
    int data[MAX_SIZE];
    int top;
} Stack;

1.2 队列的本质与实现变体

队列的基本操作包括：

enqueue(入队)：在队尾添加元素
dequeue(出队)：移除并返回队首元素
front(查看队首)：返回但不移除队首元素
isEmpty(判空)：检查队列是否为空

队列在实际应用中常见的变体有：

循环队列：解决普通队列的"假溢出"问题
双端队列(deque)：两端都可进行插入删除
优先队列：元素带有优先级，按优先级出队

c复制// 循环队列的实现示例
#define QUEUE_SIZE 100

typedef struct {
    int data[QUEUE_SIZE];
    int front, rear;
} CircularQueue;

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 栈与队列的C语言实现细节

2.1 栈的完整实现与边界处理

一个健壮的栈实现需要考虑各种边界条件。以下是基于数组的完整实现：

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

#define STACK_SIZE 100

typedef struct {
    int items[STACK_SIZE];
    int top;
} Stack;

void initialize(Stack *s) {
    s->top = -1;
}

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

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

void push(Stack *s, int value) {
    if (isFull(s)) {
        printf("栈溢出！无法压入 %d\n", value);
        return;
    }
    s->items[++(s->top)] = value;
}

int pop(Stack *s) {
    if (isEmpty(s)) {
        printf("栈下溢！\n");
        exit(EXIT_FAILURE);
    }
    return s->items[(s->top)--];
}

int peek(Stack *s) {
    if (isEmpty(s)) {
        printf("栈为空\n");
        exit(EXIT_FAILURE);
    }
    return s->items[s->top];
}

关键点：每次操作前必须检查栈空/满条件，这是新手最容易忽略的地方。我在实际项目中见过太多因为没有做这些检查而导致的段错误。

2.2 队列的完整实现与循环优化

普通队列的实现有个明显问题：随着元素不断出队，前面的空间就浪费了。循环队列通过模运算解决了这个问题：

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

#define QUEUE_SIZE 100

typedef struct {
    int items[QUEUE_SIZE];
    int front, rear;
} Queue;

void initialize(Queue *q) {
    q->front = -1;
    q->rear = -1;
}

bool isFull(Queue *q) {
    return (q->rear + 1) % QUEUE_SIZE == q->front;
}

bool isEmpty(Queue *q) {
    return q->front == -1;
}

void enqueue(Queue *q, int value) {
    if (isFull(q)) {
        printf("队列已满！\n");
        return;
    }
    if (isEmpty(q)) {
        q->front = 0;
    }
    q->rear = (q->rear + 1) % QUEUE_SIZE;
    q->items[q->rear] = value;
}

int dequeue(Queue *q) {
    if (isEmpty(q)) {
        printf("队列为空！\n");
        exit(EXIT_FAILURE);
    }
    int item = q->items[q->front];
    if (q->front == q->rear) {
        q->front = q->rear = -1;
    } else {
        q->front = (q->front + 1) % QUEUE_SIZE;
    }
    return item;
}

循环队列的关键在于：

入队时rear指针的计算：(rear + 1) % size
出队时front指针的计算：(front + 1) % size
判断队列满的条件：(rear + 1) % size == front

3. 栈与队列的高级应用场景

3.1 栈在算法中的典型应用

函数调用栈：每次函数调用都会在栈中创建一个栈帧，存储局部变量和返回地址
表达式求值：中缀表达式转后缀表达式，以及后缀表达式求值都依赖栈

c复制// 使用栈检查括号匹配的示例
bool isBalanced(char exp[]) {
    Stack s;
    initialize(&s);
    
    for (int i = 0; exp[i] != '\0'; i++) {
        if (exp[i] == '(' || exp[i] == '{' || exp[i] == '[') {
            push(&s, exp[i]);
        } else if (exp[i] == ')' || exp[i] == '}' || exp[i] == ']') {
            if (isEmpty(&s)) return false;
            
            char top = pop(&s);
            if (!((top == '(' && exp[i] == ')') || 
                  (top == '{' && exp[i] == '}') || 
                  (top == '[' && exp[i] == ']'))) {
                return false;
            }
        }
    }
    return isEmpty(&s);
}

深度优先搜索(DFS)：递归实现的DFS本质上就是使用调用栈，非递归实现则需要显式使用栈

3.2 队列在系统设计中的应用

消息队列：生产者-消费者问题的经典解决方案
打印任务队列：多个打印任务按到达顺序处理
广度优先搜索(BFS)：必须使用队列来实现
缓存实现：如LRU缓存淘汰算法

c复制// 使用队列实现BFS的伪代码
void BFS(Graph *graph, int startVertex) {
    Queue q;
    initialize(&q);
    bool visited[MAX_VERTICES] = {false};
    
    visited[startVertex] = true;
    enqueue(&q, startVertex);
    
    while (!isEmpty(&q)) {
        int current = dequeue(&q);
        printf("%d ", current);
        
        for (每个与current相邻的顶点v) {
            if (!visited[v]) {
                visited[v] = true;
                enqueue(&q, v);
            }
        }
    }
}

4. 性能分析与优化技巧

4.1 时间复杂度对比

操作	栈(数组)	栈(链表)	队列(数组)	队列(链表)
插入	O(1)	O(1)	O(1)	O(1)
删除	O(1)	O(1)	O(1)	O(1)
访问顶部	O(1)	O(1)	O(1)	O(1)
搜索	O(n)	O(n)	O(n)	O(n)

虽然时间复杂度相同，但实际性能有差异：

数组实现：缓存友好，但大小固定
链表实现：动态大小，但每个操作都有内存分配开销

4.2 内存管理技巧

动态扩容策略：当栈/队列满时，可以动态扩容(通常是2倍)

c复制// 动态栈的扩容示例
void pushDynamic(StackDynamic *s, int value) {
    if (s->top == s->capacity - 1) {
        s->capacity *= 2;
        s->items = realloc(s->items, s->capacity * sizeof(int));
        if (!s->items) {
            printf("内存分配失败！\n");
            exit(EXIT_FAILURE);
        }
    }
    s->items[++(s->top)] = value;
}

内存池技术：频繁创建销毁节点时，可以预分配内存池
碎片整理：对于循环队列，定期整理可以优化空间利用率

4.3 多线程环境下的线程安全实现

在并发环境中，简单的栈/队列实现会导致竞态条件。常见的解决方案：

互斥锁保护：

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

void ts_push(ThreadSafeStack *s, int value) {
    pthread_mutex_lock(&s->lock);
    // 压栈操作
    pthread_mutex_unlock(&s->lock);
}

无锁实现：使用原子操作(C11标准支持)
读写分离：多读单写场景下的优化

5. 常见问题与调试技巧

5.1 栈溢出与栈下溢

栈溢出：尝试向已满的栈压入元素
- 现象：数据损坏或程序崩溃
- 解决方法：实现isFull检查，考虑动态扩容
栈下溢：尝试从空栈弹出元素
- 现象：返回垃圾值或程序崩溃
- 解决方法：实现isEmpty检查

调试技巧：在调试版本中加入断言(assert)，发布版本中改为错误处理

5.2 队列的假溢出问题

普通数组实现的队列在rear到达数组末尾时，即使前面有空位也无法使用，这就是假溢出。

解决方案：

使用循环队列
动态扩容并移动元素
链表实现

5.3 内存泄漏问题

链表实现的栈/队列容易忘记释放节点内存：

c复制// 正确的链表栈销毁
void destroyStack(LinkedStack *s) {
    while (!isEmpty(s)) {
        Node *temp = pop(s);
        free(temp);
    }
}

检查工具：

Valgrind(Memcheck)
AddressSanitizer
静态分析工具

5.4 性能瓶颈分析

当栈/队列操作成为性能瓶颈时：

使用profiler(gprof, perf)定位热点
考虑批量操作替代单次操作
评估数据结构是否合适(可能需要换跳表、哈希等)

我在实际项目中遇到过的一个案例：一个高频交易系统使用标准库的队列导致性能不达标，改用环形缓冲区和无锁编程后性能提升了8倍。