C 语言栈实现详解：从原理到动态扩容与工程化应用（含顺序/链式对比、函数调用栈、表达式求值等）

于 2025-05-31 23:22:19 发布
阅读量538 收藏 8
点赞数 18
分类专栏： IT 洞察集 文章标签： C 语言 栈数据结构 动态扩容 顺序栈 链式栈 工程化应用 算法实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53139964/article/details/148357288
版权

        栈（Stack）作为计算机科学中最基础的数据结构之一，凭借其 "后进先出"（LIFO）的特性，在函数调用、表达式求值、内存管理、括号匹配等场景中发挥着核心作用。本文将从底层原理、分类对比、完整实现到高级应用进行系统性讲解，并结合 C 语言代码深入剖析其技术细节。

一、栈的核心特性与底层原理

1.1 栈的本质特性

  • 严格的存取顺序：所有操作（入栈/出栈）仅在栈顶进行，禁止随机访问。
  • 时间复杂度保证：所有基本操作（push/pop/peek）均为 O(1) 时间复杂度。
  • 空间局部性：顺序栈的连续内存分配特性有利于 CPU 缓存命中。

1.2 栈的抽象数据类型（ADT）定义

// 栈的抽象接口定义（C语言风格）
typedef struct {
    void (*init)(void*);      // 初始化
    bool (*isEmpty)(void*);   // 判空
    bool (*isFull)(void*);    // 判满（顺序栈特有）
    bool (*push)(void*, int); // 入栈
    bool (*pop)(void*, int*); // 出栈
    bool (*peek)(void*, int*); // 获取栈顶
    void (*destroy)(void*);   // 销毁
} StackADT;

二、栈的两种实现方式对比

2.1 顺序栈（基于数组）

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

#define INITIAL_CAPACITY 8

typedef struct {
    int *data;        // 动态数组存储数据
    int top;          // 栈顶指针
    int capacity;     // 当前容量
} ArrayStack;

// 初始化顺序栈（支持动态扩容）
void initArrayStack(ArrayStack *stack) {
    stack->data = (int*)malloc(INITIAL_CAPACITY * sizeof(int));
    stack->top = -1;
    stack->capacity = INITIAL_CAPACITY;
}

// 动态扩容函数
bool resizeStack(ArrayStack *stack, int newCapacity) {
    int *newData = (int*)realloc(stack->data, newCapacity * sizeof(int));
    if (!newData) return false;
    stack->data = newData;
    stack->capacity = newCapacity;
    return true;
}

// 完整顺序栈实现（包含动态扩容）
typedef struct {
    // ...（同上）
} DynamicArrayStack;

// 其余操作（push/pop/peek等）实现...

优势：

  • 内存连续分配，缓存友好。
  • 无需额外指针空间。
  • 随机访问（虽然栈通常不需要）。

劣势：

  • 固定容量需要预先分配或动态扩容。
  • 扩容时有 O(n) 时间开销（但均摊 O(1)）。

2.2 链式栈（基于链表）

typedef struct StackNode {
    int data;
    struct StackNode *next;
} StackNode;

typedef struct {
    StackNode *top; // 栈顶指针
    int size;       // 栈大小（可选）
} LinkedStack;

// 初始化链式栈
void initLinkedStack(LinkedStack *stack) {
    stack->top = NULL;
    stack->size = 0;
}

// 链式栈入栈操作
bool pushLinked(LinkedStack *stack, int value) {
    StackNode *newNode = (StackNode*)malloc(sizeof(StackNode));
    if (!newNode) return false;
    newNode->data = value;
    newNode->next = stack->top;
    stack->top = newNode;
    stack->size++;
    return true;
}

// 链式栈出栈操作
bool popLinked(LinkedStack *stack, int *value) {
    if (!stack->top) return false;
    StackNode *temp = stack->top;
    *value = temp->data;
    stack->top = temp->next;
    free(temp);
    stack->size--;
    return true;
}

优势：

  • 动态内存分配，无容量限制。
  • 无需预先分配空间。
  • 插入/删除仅需修改指针。

劣势：

  • 每个节点需要额外指针空间。
  • 内存分配/释放开销较大。
  • 缓存不友好（非连续内存）。

三、C 语言完整实现：带动态扩容的顺序栈

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define INITIAL_CAPACITY 4
#define GROWTH_FACTOR 2

typedef struct {
    int *data;
    int top;
    int capacity;
} ResizableStack;

// 初始化栈
void initStack(ResizableStack *stack) {
    stack->data = (int*)malloc(INITIAL_CAPACITY * sizeof(int));
    if (!stack->data) {
        perror("内存分配失败");
        exit(EXIT_FAILURE);
    }
    stack->top = -1;
    stack->capacity = INITIAL_CAPACITY;
}

// 判断栈是否为空
bool isEmpty(ResizableStack *stack) {
    return stack->top == -1;
}

// 判断栈是否已满
bool isFull(ResizableStack *stack) {
    return stack->top == stack->capacity - 1;
}

// 动态扩容
bool resize(ResizableStack *stack, int newCapacity) {
    int *newData = (int*)realloc(stack->data, newCapacity * sizeof(int));
    if (!newData) return false;
    stack->data = newData;
    stack->capacity = newCapacity;
    return true;
}

// 入栈操作（带动态扩容）
bool push(ResizableStack *stack, int value) {
    if (isFull(stack)) {
        if (!resize(stack, stack->capacity * GROWTH_FACTOR)) {
            return false;
        }
    }
    stack->data[++stack->top] = value;
    return true;
}

// 出栈操作
bool pop(ResizableStack *stack, int *value) {
    if (isEmpty(stack)) return false;
    *value = stack->data[stack->top--];
    
    // 可选：动态缩容（当元素数量小于1/4容量时）
    if (stack->top > 0 && stack->top == stack->capacity / 4 / GROWTH_FACTOR) {
        resize(stack, stack->capacity / GROWTH_FACTOR);
    }
    return true;
}

// 获取栈顶元素
bool peek(ResizableStack *stack, int *value) {
    if (isEmpty(stack)) return false;
    *value = stack->data[stack->top];
    return true;
}

// 销毁栈
void destroyStack(ResizableStack *stack) {
    free(stack->data);
    stack->data = NULL;
    stack->top = -1;
    stack->capacity = 0;
}

// 测试代码
int main() {
    ResizableStack stack;
    initStack(&stack);

    // 测试入栈
    for (int i = 1; i <= 15; i++) {
        push(&stack, i);
        printf("入栈 %d, 当前栈大小: %d, 容量: %d\n", 
               i, stack.top + 1, stack.capacity);
    }

    // 测试出栈
    int value;
    while (!isEmpty(&stack)) {
        pop(&stack, &value);
        printf("出栈 %d\n", value);
    }

    destroyStack(&stack);
    return 0;
}

四、栈的高级应用场景

4.1 函数调用栈（Call Stack）

  • 调用栈结构：每个函数调用在栈上分配栈帧（Stack Frame），包含：
    • 返回地址
    • 局部变量
    • 参数
    • 保存的寄存器状态
  • 栈溢出（Stack Overflow）：递归过深或局部变量过大导致。
  • 尾调用优化（TCO）：编译器优化尾递归为循环，避免栈增长。

4.2 表达式求值与转换

  • 中缀转后缀表达式（逆波兰表示法）：
// 示例：中缀表达式 "3 + 4 * 2 / (1 - 5)"
// 转换为后缀表达式: "3 4 2 * 1 5 - / +"
  • 后缀表达式求值：
// 算法步骤：
// 1. 初始化空栈
// 2. 扫描后缀表达式
//    - 遇到操作数：入栈
//    - 遇到运算符：弹出栈顶两个元素进行运算，结果入栈
// 3. 最终栈顶元素即为结果

4.3 括号匹配验证

#include <stdbool.h>

bool isValidParentheses(const char *s) {
    ResizableStack stack;
    initStack(&stack);
    
    for (int i = 0; s[i] != '\0'; i++) {
        char c = s[i];
        if (c == '(' || c == '[' || c == '{') {
            push(&stack, c);
        } else {
            if (isEmpty(&stack)) {
                destroyStack(&stack);
                return false;
            }
            char top;
            peek(&stack, &top);
            if ((c == ')' && top != '(') ||
                (c == ']' && top != '[') ||
                (c == '}' && top != '{')) {
                destroyStack(&stack);
                return false;
            }
            pop(&stack, &top);
        }
    }
    
    bool result = isEmpty(&stack);
    destroyStack(&stack);
    return result;
}

4.4 浏览器前进/后退功能

// 使用两个栈实现浏览器历史记录
typedef struct {
    ResizableStack backStack;  // 后退栈
    ResizableStack forwardStack; // 前进栈
    char *currentPage;        // 当前页面
} BrowserHistory;

void visitPage(BrowserHistory *history, const char *newPage) {
    // 将当前页面压入后退栈
    if (history->currentPage) {
        push(&history->backStack, (int)history->currentPage); // 简化处理，实际应存储字符串指针
    }
    // 清空前进栈
    while (!isEmpty(&history->forwardStack)) {
        pop(&history->forwardStack, NULL); // 丢弃
    }
    // 更新当前页面
    history->currentPage = strdup(newPage); // 实际实现中应处理内存
}

void goBack(BrowserHistory *history) {
    if (isEmpty(&history->backStack)) return;
    
    // 将当前页面压入前进栈
    push(&history->forwardStack, (int)history->currentPage);
    // 弹出后退栈顶作为新当前页面
    int page;
    pop(&history->backStack, &page);
    history->currentPage = (char*)page; // 简化处理
}

五、性能优化与工程实践

5.1 动态扩容策略

  • 几何扩容：每次扩容为当前容量的k倍（如k=2）
  • 均摊分析：虽然扩容时为O(n)，但均摊时间复杂度仍为O(1)
  • 缩容策略：当元素数量小于1/4容量时进行缩容，避免内存浪费

5.2 线程安全栈实现

#include <pthread.h>

typedef struct {
    ResizableStack stack;
    pthread_mutex_t lock;
} ThreadSafeStack;

void initThreadSafeStack(ThreadSafeStack *tsStack) {
    initStack(&tsStack->stack);
    pthread_mutex_init(&tsStack->lock, NULL);
}

bool tsPush(ThreadSafeStack *tsStack, int value) {
    pthread_mutex_lock(&tsStack->lock);
    bool result = push(&tsStack->stack, value);
    pthread_mutex_unlock(&tsStack->lock);
    return result;
}

// 其他线程安全操作...

5.3 泛型栈实现（使用 void 指针）

typedef struct {
    void **data;
    int top;
    int capacity;
    size_t elementSize; // 元素大小
} GenericStack;

void initGenericStack(GenericStack *stack, size_t elementSize) {
    stack->data = malloc(INITIAL_CAPACITY * sizeof(void*));
    stack->top = -1;
    stack->capacity = INITIAL_CAPACITY;
    stack->elementSize = elementSize;
}

bool genericPush(GenericStack *stack, const void *element) {
    if (isFull(stack)) {
        if (!resize(stack, stack->capacity * GROWTH_FACTOR)) {
            return false;
        }
    }
    stack->data[++stack->top] = malloc(stack->elementSize);
    memcpy(stack->data[stack->top], element, stack->elementSize);
    return true;
}

六、总结与扩展思考

6.1 栈的核心价值

  • 简化问题建模：将复杂问题转化为栈操作序列。
  • 提高代码可读性：通过栈操作表达明确的业务逻辑。
  • 优化内存使用：避免不必要的全局变量和复杂数据结构。

6.2 扩展研究方向

  • 栈机器（Stack Machine）：基于栈的虚拟机实现。
  • 栈自动机（Stack Automaton）：用于形式语言理论中的上下文无关语言识别。
  • 栈在并发编程中的应用：如CSP模型中的通道实现。

        栈作为计算机科学的基础构件，其设计思想贯穿于从编译器优化到分布式系统的各个层面。深入理解栈的实现原理和应用场景，能够帮助开发者编写出更高效、更健壮的程序。在实际工程中，应根据具体需求选择合适的栈实现方式，并考虑动态扩容、线程安全等工程化问题。

【LangChain编程：从入门到实践】自定义提示模板原理与应用实战 系列文章
AI天才研究院
06-21 1002
随着人工智能技术的快速发展,特别是自然语言处理领域的突破,大语言模型(LLM)正在重塑人机交互的方式。LLM能够理解和生成接近人类水平的自然语言,为构建智能对话系统和知识应用带来了新的机遇。然而,直接使用LLM进行应用开发往往需要大量的prompt engineering工作,而且缺乏组合不同LLM能力的灵活性。这些挑战催生了一个新的编程范式—— LangChain。LangChain是一个面向LLM应用开发的开源框架,它提供了一系列工具和最佳实践,帮助开发者更轻松地构建LLM驱动的应用。
Kotlin内联函数：提升Android应用性能的隐藏技巧
移动开发前沿的博客
05-18 443
本文旨在全面解析Kotlin内联函数的工作原理及其在Android开发中的性能优化价值。我们将深入探讨内联函数如何通过编译时优化减少运行时开销，分析其在内存分配和执行效率方面的优势，并提供实际应用场景和代码示例。文章首先介绍内联函数的基本概念，然后深入其实现原理和性能优势，接着通过实际案例展示应用场景，最后讨论相关工具和未来发展趋势。内联函数(Inline Function)：在编译时将函数体直接插入调用处的函数，消除函数调用的开销高阶函数(Higher-Order Function)
C语言——函数，return语句，嵌套调用和链式访问详解，函数的声明和定义，static和extern
2302_80244431的博客
08-07 1370
C语言——函数＋return语句详解＋嵌套调用和链式访问详解，函数的声明和定义，static和extern
C语言函数详解
热门推荐
qq_65285898的博客
04-26 8万+
函数作为C语言的基本组成元素，让我们深入认识这个熟悉又陌生的朋友
Java 8 Lambda表达式详解：从入门到实践
weixin_44283682的博客
02-07 2021
Lambda表达式的引入，是Java语言发展的一个重要里程碑。它不仅使Java代码更简洁、更易读，还为Java带来了函数式编程的强大能力。Lambda表达式与Stream API（后续章节将详细介绍）的结合，更是开启了Java集合处理的新篇章。
C语言中的函数（超详细）
m0_68662723的博客
07-25 7万+
我们都知道函数是数学里的重要组成部分，数学中我们常见到函数的概念，但是你了解C语言中的函数吗？其实函数就相当于一个子程序，那什么是子程序呢？在计算机科学中，子程序是一个大型程序中的某部分代码， 由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代 码，具备相对的独立性。一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。如果库函数能干所有的事情，那还要程序员干什么？所有更加重要的是自定义函数！！！
【C语言】基本语法知识&&C语言函数&&操作符详解
m0_74722801的博客
03-20 4458
【C语言】基本语法知识&&C语言函数&&操作符详解
数据结构：栈、队列、数组 详解
Cerulea_n的博客
07-01 1064
1。
JDK8新特性--Lambda表达式,接口新增方法,常用内置函数式接口,方法引用详解
2401_85014515的博客
07-07 819
总结了Java 8的主要特性和优势。强调了Lambda表达式和Stream API的引入，使Java编程更为简洁和灵活。Lambda表达式通过简化匿名内部类的语法，提升了代码的可读性和表达能力，特别适用于函数式接口的实现。同时，Stream API提供了流式操作，支持链式调用和并行处理，极大地简化了集合数据的处理和转换。另外，Optional类有效减少了空指针异常的风险，增强了代码的健壮性。这些特性共同推动了Java语言的现代化，使其在大数据处理和并发编程等领域具备了更强的竞争力和适用性。
C生万物 | 函数的讲解与剖析【内附众多案例详解】
做技术人 · 产优质博客 · 找好工作
01-13 2069
全面了解C语言中函数的内容，带你从浅至深学会函数的使用
Java 2nd版：模块、流、线程、I/O与Lambda表达式详解
《Java语言特性，第二版》是一本深度探讨Java编程语言的权威指南，由Kishori Sharan编著。本书针对Java的最新特性进行了详尽讲解，包括模块化（Modules）、流（Streams）、线程（Threads）、I/O操作以及lambda表达式...
C语言中的函数（保姆级详细讲解）
2401_86080061的博客
07-29 1301
1 ret_type fun_name(形式参数)2 {34 }• ret_type 是函数返回类型，有时候返回类型可以是void ，表示什么都不返回• fun_name 是函数名• 括号中是形式参数• {}中是函数体我们可以把函数想象成一个小型工厂，即参数需要经过函数的计算才能得出结果。函数的参数也可以是 void ，明确表示函数没有参数。如果有参数，要交代清楚参数的类型和名字，以及参数个数。int z = 0;z = x+y;return z;int main()
23种设计模式详解与Java/C++源码实现
设计模式是在软件工程领域中，对于一些常见问题提供通用解决方案的一种形式。它们是软件设计中可复用的模板，通常分为三大类：创建型模式、结构型模式和行为型模式。以下为23种设计模式的详细知识点分析与实现源代码...
基于vue与netty的微信猜数对战小游戏.zip
06-03
基于vue与netty的微信猜数对战小游戏.zip
基于Vue和Node的MongoDB个人博客系统设计.zip
06-03
基于Vue和Node的MongoDB个人博客系统设计.zip
体育公寓7-公园广场景观CAD平面方案立面节点大样施工图.zip
06-03
体育公寓7-公园广场景观CAD平面方案立面节点大样施工图.zip
办公室布局方案CAD-网络科技公司办公室 平面图.zip
06-03
办公室布局方案CAD-网络科技公司办公室 平面图.zip
Dax233_Tools_20444_1747162348958.zip
最新发布
06-03
Dax233_Tools_20444_1747162348958
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Thanks_ks

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值