数据结构-栈（stack）

数据结构-栈的实现与应用
原创 已于 2025-09-15 23:04:54 修改 · 1k 阅读 · 25 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #算法 #vscode #栈

于 2025-09-14 09:39:23 首次发布

一.栈的基本概念

        栈（Stack）是一种线性数据结构，遵循**后进先出（LIFO, Last In First Out）**原则。最后插入的元素最先被访问或删除。看栈顶等）。

二.栈的核心操作

设计结构体并初始化

入栈（Push）操作：

        将元素添加到栈顶。若栈已满（固定容量实现时即顺序栈），此操作需要检查栈满否则可能导致栈溢出（Stack Overflow）。


出栈（Pop）操作：

        移除并返回栈顶元素。若栈为空，此操作需要检查栈是否为空，否则可能导致栈下溢（Stack Underflow）。


查看栈顶（Top）操作

        返回栈顶元素但不移除它。也需要判断栈是否为空，因为空栈时操作无效。

三.栈的实现方式

1.顺序表实现栈

        结构体设计
struct seqStack    //定义结构体类型
{
    int *data;     //存储入栈的数据
    int size;      //顺序栈的容量
    int top;       //栈顶位置
};
       初始化

        顺序栈（seqStack）的初始化函数 initStack，为栈结构分配内存并设置初始状态。

        以下是逐步分析：

  • 动态分配 struct seqStack 类型的内存空间，并将指针赋给 stack。若分配失败，malloc 返回 NULL。

  • 若栈结构内存分配成功，继续为栈的存储数组 data 分配空间。这里使用 calloc 分配 size 个 int 大小的空间，并初始化为 0。

  • 若 data 分配失败，释放之前分配的 stack 内存，避免内存泄漏，并返回 NULL 表示初始化失败。

  • 初始化栈的容量 size 和栈顶指针 top（-1 表示空栈）。

  • 最终返回栈指针 stack（为 NULL 表示失败）。

//初始化栈，传入栈的容量
struct seqStack * initStack(int size)
{
    struct seqStack *stack = malloc(sizeof(struct seqStack));   //申请内存空间
    if(stack != NULL)                                           //确保申请成功
    {
        stack->data = calloc(size, sizeof(int));                //申请数据存储空间
        if(stack->data == NULL)                                 //申请失败释放空间，返回空避免内存泄漏
        {
            free(stack);
            return NULL;
        }
        stack->size = size;                                     //容量赋初值
        stack->top = -1;                                        //栈顶指针赋初值
    }
    return stack;
}
        入栈

        实现顺序栈的入栈操作（push）

        以下是逐步分析：

        入栈操作前，要检查栈满

        isFULL函数实现

  • 判断栈满，通过栈顶指针（top），当栈顶指针等于栈的容量-1则栈满（初始栈顶指针为-1，从零开始，因此这里需要减1）

  • //判断栈满
bool isFULL(struct seqStack *stack)
{
    return stack->top >=stack->size-1;  //0-size计数
}

        push函数实现：

  • 函数返回布尔类型，表示操作是否成功；参数stack是指向顺序栈结构的指针；参数data是要入栈的整型数据。

  • 调用isFULL函数检查栈是否已满。如果栈满，输出错误信息并通过perror打印错误，并返回false表示入栈失败。

  • 栈顶指针top先自增，指向新的栈顶位置然后将数据data存储在新的栈顶位置data[stack->top]。这里使用的是前自增操作符++，确保先移动指针再存储数据。

  • 操作成功完成，返回true。

//入栈
bool push(struct seqStack *stack, int data)
{
    if(isFULL(stack))
    {
        perror("isfull");return false;
    }
        
    stack->data[++stack->top] = data;   //存储传入的数据，修改栈顶指针的位置
    return true;
}

            出栈

            出栈和取栈顶元素需要判断栈空

            isEmpty函数实现：

    //判断栈空
bool isEmpty(struct seqStack *stack)
{
    return stack->top == -1;
}

            top函数实现：

    • 参数struct seqStack *stack：指向顺序栈结构的指针；

    • 参数int *m：用于存储获取到的栈顶元素的指针；

            1.调用isEmpty(stack)检查栈是否为空 如果栈为空，输出错误信息"isempty"并返回false

            2.当栈不为空时，通过stack->data[stack->top]访问栈顶元素 将栈顶元素的值赋给指针m所指向的内存位置，最后返回true表示操作成功。

    //取栈顶元素
bool top(struct seqStack *stack, int *m)
{
    if(isEmpty(stack))
    {
        perror("isempty\n");
        return false;
    }
        
    *m = stack->data[stack->top];
    return true;
}
    取栈顶元素

    pop函数实现：

    接收两个参数：指向栈结构的指针 stack 和用于返回栈顶元素的指针 m。

    调用 top 函数检查栈是否为空并获取栈顶元素。

    如果栈为空，top 返回 false，pop 也直接返回 false。

    如果栈不为空，栈顶指针 top 减一，完成出栈操作，并返回 true 表示出栈成功。

    //出栈
bool pop(struct seqStack *stack, int *m)
{
    if(!top(stack, m))
    {
        
        return false;
    }
        
    stack->top--;
    return true;
}
    主函数
    //主函数
int main(void)
{
    struct seqStack *stack = initStack(10);
    if(stack == NULL)
    {
        perror("初始化顺序栈失败\n");
        exit(0);
    }
    else
    printf("初始化成功\n");

    push(stack, 3);
    push(stack, 4);
    push(stack, 5);
    printf("\n");
    while(!isEmpty(stack))
    {
        int m;
        pop(stack, &m);
        printf("%d\n", m);
    }
    return 0;
    完整代码：
    #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdbool.h>


struct seqStack    //定义结构体类型
{
    int *data;     //存储入栈的数据
    int size;      //顺序栈的容量
    int top;       //栈顶位置
};

//初始化栈，传入栈的容量
struct seqStack * initStack(int size)
{
    struct seqStack *stack = malloc(sizeof(struct seqStack));   //申请内存空间
    if(stack != NULL)                                           //确保申请成功
    {
        stack->data = calloc(size, sizeof(int));                //申请数据存储空间
        if(stack->data == NULL)                                 //申请失败释放空间，返回空避免内存泄漏
        {
            free(stack);
            return NULL;
        }
        stack->size = size;                                     //容量赋初值
        stack->top = -1;                                        //栈顶指针赋初值
    }
    return stack;
}

//判断栈满
bool isFULL(struct seqStack *stack)
{
    return stack->top >=stack->size-1;  //0-size计数
}

//入栈
bool push(struct seqStack *stack, int data)
{
    if(isFULL(stack))
    {
        perror("isfull");return false;
    }
        
    stack->data[++stack->top] = data;   //存储传入的数据，修改栈顶指针的位置
    return true;
}

//判断栈空
bool isEmpty(struct seqStack *stack)
{
    return stack->top == -1;
}


//取栈顶元素
bool top(struct seqStack *stack, int *m)
{
    if(isEmpty(stack))
    {
        perror("isempty\n");
        return false;
    }
        
    *m = stack->data[stack->top];
    return true;
}

//出栈
bool pop(struct seqStack *stack, int *m)
{
    if(!top(stack, m))
    {
        
        return false;
    }
        
    stack->top--;
    return true;
}

//主函数
int main(void)
{
    struct seqStack *stack = initStack(10);
    if(stack == NULL)
    {
        perror("初始化顺序栈失败\n");
        exit(0);
    }
    else
    printf("初始化成功\n");

    push(stack, 3);
    push(stack, 4);
    push(stack, 5);

    printf("\n");
    while(!isEmpty(stack))
    {
        int m;
        pop(stack, &m);
        printf("%d\n", m);
    }
    return 0;
}
    顺序栈的优缺点
    优点

    • 内存连续：顺序栈基于数组实现，内存连续访问效率高，CPU缓存命中率更高。

    • 操作简单：入栈（push）和出栈（pop）仅需操作栈顶指针，时间复杂度为 O(1)。

    • 节省空间：无需存储额外指针，仅需一个数组和栈顶指针即可实现。

    缺点

    • 固定容量：栈大小需预先定义，可能导致空间浪费或栈溢出（需动态扩容，但扩容有性能开销）。

    • 扩容成本高：动态扩容需重新分配内存并复制数据，时间复杂度为 O(n)。


    链表实现栈

            栈是一种后进先出（LIFO）的数据结构，链表是一种动态数据结构，通过指针连接节点。用链表实现栈时，栈顶通常是链表的头节点，入栈和出栈操作均在链表头部进行，保证时间复杂度为 O(1)。

     结构体设计
    • 链式存储：通过next指针实现动态内存分配，无需预先定义栈容量。
    • 组合设计：将栈顶指针top和栈大小size封装在linkstack结构中，便于状态管理。
    • 指针类型别名：使用typedef将struct linkstack*定义为Linkstack，简化代码书写。
    struct nodestack            //节点设计
{
    int data;
    struct nodestack* next;
};

typedef struct linkstack    //栈结构设计
{
    struct nodestack* top;
    int size;
}*Linkstack;
       
     初始化

            Linkstack initlinkstack()实现初始化链式栈。

    内存分配

    • 使用malloc动态分配struct linkstack大小的内存空间

    • 检查分配是否成功（stack!=NULL）

    初始化成员

    • 将栈顶指针top初始化为NULL，表示空栈

    • 将栈大小size初始化为0，表示没有元素

    //初始化链式栈
Linkstack initlinkstack()
{
    Linkstack stack = malloc(sizeof(struct linkstack));
    if(stack!=NULL)
    {
        stack->top = NULL;
        stack->size = 0;
    }
    
    return stack;
}
            入栈

            实现链式栈的入栈操作（push）

            push函数实现：

            动态分配新节点内存
            通过 malloc 创建新节点 node，并检查内存分配是否成功， 处理分配失败的情况。

            节点数据赋值
            将参数 data 存入新节点的 data 字段，完成数据初始化。

            调整链表指针
            新节点的 next 指针指向当前栈顶节点 stack->top，建立链表连接关系。

            更新栈顶指针
            栈的 top 指针指向新节点，使新节点成为新的栈顶元素。

            栈大小维护
            递增 stack->size ，保持栈的当前元素数量同步更新。

    //入栈，创建新的节点，链接链表
bool push(Linkstack stack, int data)
{
    struct nodestack *node = malloc(sizeof(struct nodestack));
    if (node == NULL) 
        return false;
    node->data = data;
    node->next = stack->top;
    stack->top = node;
    stack->size++;
    return true;
}

              出栈

              出栈和取栈顶元素需要判断栈空

              isEmpty函数实现：

      //判断栈空
bool isEmpty(Linkstack stack)
{
    return stack->size == 0;
}

              top函数实现：

      • 检查栈是否为空（调用 isEmpty(stack)），若非空则执行下一步；
      • 通过 stack->top->data 获取栈顶节点的数据，并将其赋值给 *data；
      • 返回 true 表示操作成功；
      • 若栈为空，直接返回 false 表示操作失败。
      //取栈顶元素
bool top(Linkstack stack, int *data)
{
    if(!isEmpty(stack))
    {
        *data = stack->top->data;
        return true;
    }
    return false;
}
      取栈顶元素

      pop函数实现：

      1. 空栈检查
        调用 isEmpty(stack) 判断栈是否为空，避免对空栈执行出栈操作。

      2. 出栈操作

        • 临时指针 p 保存当前栈顶节点。
        • 将 stack->top 指向下一个节点（stack->top->next）。
        • 释放 p 指向的节点内存。
        • 更新栈大小（stack->size--）。

        • 返回值

          • 成功出栈返回 true。
          • 栈空时返回 false。 
        //出栈
bool pop(Linkstack stack)
{
    if(!isEmpty(stack))
    {
            struct nodestack* p = stack->top;        //记录出栈指针，以便后续释放
            stack->top = stack->top->next;           //指针移位，指向释放结构体指针的后面
            free(p);                                 //出栈需要释放内存
            stack->size--;
            return true;
    }
    return false;
}
        主函数
        int main(void)
{
    Linkstack stack = initlinkstack();
    if(stack == NULL)printf("初始化失败\n");
    else printf("初始化成功\n");
    printf("请输入一个数\n");
    int n=0;
    scanf("%d", &n);
    while(n)//n != 0
    {
        push(stack, n--);
    }
   while(1)
    {
        int data = 0;
        if(!top(stack, &data))
        break;
        printf("%d ",data);
        printf("\n");
        pop(stack);
    }
    return 0;
}
        完整代码：
        #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdbool.h>

struct nodestack            //节点设计
{
    int data;
    struct nodestack* next;
};

typedef struct linkstack    //栈结构设计
{
    struct nodestack* top;
    int size;
}*Linkstack;

//初始化链式栈
Linkstack initlinkstack()
{
    Linkstack stack = malloc(sizeof(struct linkstack));
    if(stack!=NULL)
    {
        stack->top = NULL;
        stack->size = 0;
    }
    
    return stack;
}

//入栈，创建新的节点，链接链表
bool push(Linkstack stack, int data)
{
    struct nodestack *node = malloc(sizeof(struct nodestack));
    if (node == NULL) 
        return false;
    node->data = data;
    node->next = stack->top;
    stack->top = node;
    stack->size++;
    return true;
}

//判断栈空
bool isEmpty(Linkstack stack)
{
    return stack->size == 0;
}

//取栈顶元素
bool top(Linkstack stack, int *data)
{
    if(!isEmpty(stack))
    {
        *data = stack->top->data;
        return true;
    }
    return false;
}

//出栈
bool pop(Linkstack stack)
{
    if(!isEmpty(stack))
    {
            struct nodestack* p = stack->top;        //记录出栈指针，以便后续释放
            stack->top = stack->top->next;           //指针移位，指向释放结构体指针的后面
            free(p);                                 //出栈需要释放内存
            stack->size--;
            return true;
    }
    return false;
}

int main(void)
{
    Linkstack stack = initlinkstack();
    if(stack == NULL)printf("初始化失败\n");
    else printf("初始化成功\n");
    printf("请输入一个数\n");
    int n=0;
    scanf("%d", &n);
    while(n)//n != 0
    {
        push(stack, n--);
    }
   while(1)
    {
        int data = 0;
        if(!top(stack, &data))
        break;
        printf("%d ",data);
        printf("\n");
        pop(stack);
    }
    return 0;
}
        链式栈的优缺点
        优点

        • 动态大小：基于链表实现，可动态增长，无需预先定义容量。

        • 灵活内存：节点分散存储，适合内存碎片化场景。

        • 无溢出风险：只要内存足够，理论上可无限扩展。

        缺点

        • 额外开销：每个节点需存储指针，占用更多内存。

        • 访问效率低：内存非连续，访问节点时缓存命中率低，操作速度略慢于顺序栈。

        • 代码复杂度：需处理链表节点的动态分配与释放，实现稍复杂。

        对比总结

        特性顺序栈链式栈
        内存布局连续非连续
        容量限制固定（可动态扩容）动态增长
        时间效率$O(1)$（无扩容时）$O(1)$（但常数项更高）
        空间效率更优（无指针开销）较差（需存储指针）
        适用场景已知最大容量或频繁操作容量不可预知或内存碎片多

        四.栈的应用场景

        • 函数调用栈：保存函数调用时的上下文。
        • 表达式求值：处理括号匹配、运算符优先级。
        • 浏览器历史：后退功能基于栈实现。
        • 撤销操作：文本编辑器的撤销机制。
        常用数据结构之Stack(栈)
        gaobing1993的博客
        09-24 702
        1.理论介绍 上一篇中我们介绍了数据结构中的堆，常言道堆栈不分家，我们继续来聊聊栈这种数据结构吧。栈从本质上来讲是一种有着特殊要求的线性表，感兴趣的可以了解一下之前讲的数据结构中的线性表。既然是线性表那么其就有两种形式，一种是线性存储(像数组一样是一块连续的内存空间)，另外一种是链式存储(像链表一样是一段非连续的空间)； 栈的特殊要求就是LIFO(Last In First Out)，对，后进先出。只有栈顶的元素允许访问。还记得上一篇讲的堆吗？从本质上来讲堆也是只有顶部的...
        数据结构-栈stack（链栈，顺序栈）
        [SZU_Crayon]
        04-15 1044
        一、栈的概念1）介绍栈STL时已经有写，大家可以翻翻，传送门：点击打开链接2）没有提过栈底，栈底：在顺序栈中指的是 -1下标，大家自己往下看嘻嘻。二、顺序栈1.顺序栈图解2.特点    1）空间有限，因为是一次性分配数组空间，有栈满情况。    2）出栈入栈是下标top变化，实际出栈只是下标后退一位，实际数值还在数组中，浪费内存。3.扔一段代码/*顺序栈*/ #include&lt;iostrea...
        数据结构 - 栈(Stack)
        张大安的博客
        04-30 3084
        文章目录栈的介绍用数组模拟栈栈实现计算器 栈的介绍 栈的英文为(stack)。 栈是一个先入后出(FILO : First In Last Out)的有序列表。 栈（stack）是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊的线性表。允许插入和删除的一端，为变化的一端，称为栈顶（Top），另一端为固定的一端，称为栈底（Bottom）。 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶；而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。 入栈(push)示
        栈及其应用
        weixin_33824363的博客
        11-07 112
        栈 Stack 　　栈又称堆栈，是一种运算受限的线性表，其限制是仅允许在表的一端进行插入和删除运算。 　　把对栈进行运算的一端称为栈顶，另一端称为栈底。 　　向一个栈插入新元素称为入栈或进栈，Push；从一个栈删除元素称为退栈或出栈，Pop。 　　因为后进栈的元素必定先出栈，所以又把栈称为后进先出表（Last In First Out, LIFO）。   栈的顺序存储结构 　　栈的顺...
        【数据结构】栈（stack）
        最新发布
        lightqjx的博客
        07-19 1018
        对于数据结构中关于栈的理解，栈包含顺序栈和链栈，文章实现了顺序栈（动态）和链栈。 顺序栈（动态）采用了动态顺序表实现；链栈采用了无哨兵头结点的单链表实现。
        数据结构——Stack
        zhangquanit的专栏
        08-02 666
        java的数据结构——栈
        基于C语言的数据结构-栈stack
        06-25
        在这个主题中，我们专注于栈（Stack）这一重要的数据结构，它是基于C语言实现的。栈是一种线性数据结构，遵循“后进先出”（LIFO，Last In First Out）原则，它的操作类似于日常生活中的堆叠物品，最新的添加的物品...
        数据结构-栈.zip_数据结构-栈
        09-24
        5. **自定义栈的实现**：除了使用STL的`stack`，还可以自定义栈，例如使用动态数组或链表作为底层数据结构。自定义栈的优势在于可以根据需求定制栈的行为，如增加新的操作或优化性能。 综上所述，这个压缩包提供的...
        数据结构-栈(Stack)介绍和Java示例代码
        07-01
        数据结构中的栈（Stack）是计算机科学中一种基础且重要的数据结构，它的核心特性是遵循后进先出（LIFO）原则。栈就像一个只允许在一端进行操作的线性容器，这一端被称为栈顶。栈的操作主要有两个基本操作：压栈...
        基于python的数据结构代码实现-栈Stack
        06-25
        栈（Stack）是一种特殊类型的数据结构，遵循“后进先出”（Last In First Out, LIFO）原则。栈在许多算法和问题解决中都有广泛应用，如深度优先搜索、表达式求值等。本文将详细介绍如何在Python中实现一个基本的栈...
        数据结构（Stack栈）
        weixin_45638349的博客
        09-03 334
        数据结构之——Stack （栈） 1，栈的定义 栈：先进后出的数据结构，如下图所示，先进去的数据在底部，最后取出，后进去的数据在顶部，最先被取出。 栈常用操作： s=Stack() 创建栈 s.push(item) 将数据item放在栈的顶部 s.pop() 返回栈顶部数据，并从栈中移除该数据 s.peek() 返回栈顶部数据，但不移除 s.size() 返回栈的大小 s.isEmpty() 返回栈是否
        数据结构之Stack
        weixin_52804129的博客
        10-22 267
        提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、Stack的基本概念二、使用步骤1.引入库2.读入数据总结 一、Stack的基本概念 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warn
        数据结构__stack
        chaoyueziji123的专栏
        02-24 870
        栈的定义及基本运算 1、栈的定义     　栈（Stack）是限制仅在表的一端进行插入和删除运算的线性表。 　　(1)通常称插入、删除的这一端为栈顶（Top），另一端称为栈底（Bottom）。 　　(2)当表中没有元素时称为空栈。 　　(3)栈为后进先出（Last In First Out）的线性表，简称为LIFO表。     　栈的修改是按后进先出的原则进行。每次删除（退栈）的总
        栈 Stack
        mu_tong_的博客
        06-13 812
        有关学习 栈的 笔记
        数据结构——栈（Stack）
        脑壳有点痒，好像要长脑子了！
        08-10 3599
        栈是一种线性表（俗称堆栈），它限制只能在一端（称为栈顶）进行插入和删除操作，另一端（称为栈底）是固定的，不允许进行插入和删除操作，栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针，当栈中没有元素时称为“空栈”。最大特点 ：后进先出（LIFO）。
        数据结构 -- 栈（Stack）
        qq_41217625的博客
        11-23 466
        一、栈的简介 定义 栈（stack）又称为堆栈或堆叠，栈作为一种线性数据结构，按照先进后出的原则存储数据。先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。 由于堆叠数据结构只允许在一段进行操作，因而按照后进先出（LIFO == Last In First Out）的原理运作。栈也称后进先出表。 栈的应用场景...
        数据结构——栈(stack)
        qq_64191695的博客
        07-06 1124
        栈(stack) 1.子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。 2.处理参数递归调用：和子程序的调用类似，只是除了存储下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。 3.表达式的转换【中缀表达式转后缀表达式】和求值。 4.二叉树的遍历 5.图形的深度优先搜索法栈代码实现（数组）： 输出结果： 栈实现计算器： 中缀表达式的求值是平常最为熟悉的，但是对计算机说却不好操作（上述代码有些冗杂）。因此，在计算结束时，往往会将中缀表达
        数据结构-栈满判断与进栈操作
        "判断栈满-清华大学严蔚敏数据结构" 在计算机科学中，数据结构是组织和存储数据的方式，以便高效地访问和修改。这里我们关注的是如何判断一个顺序栈（seqstack）是否已满，以及如何进行进栈操作。顺序栈是一种线性...
        评论
        成就一亿技术人!
        拼手气红包6.0元
        还能输入1000个字符
         
        红包 添加红包
        表情包 插入表情
        表情包 代码片
         条评论被折叠 查看
        添加红包

        请填写红包祝福语或标题

        个

        红包个数最小为10个

        元

        红包金额最低5元

        当前余额3.43元 前往充值 >
        需支付：10.00元
        成就一亿技术人!
        领取后你会自动成为博主和红包主的粉丝 规则
        hope_wisdom
        发出的红包
        实付元
        使用余额支付
        点击重新获取
        扫码支付
        钱包余额 0

        抵扣说明：

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

        余额充值