栈和队列

最新推荐文章于 2024-09-22 14:07:44 发布
最新推荐文章于 2024-09-22 14:07:44 发布
阅读量101 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
未经允许禁止转载
本文链接：https://blog.csdn.net/qq_42375636/article/details/108226558
版权

思维导图：点我

在这里插入图片描述

一、栈

1. 顺序栈

  1. 存储结构

    #define MaxSize 10
typedef struct
{
    ElemType data[MaxSize];
    int top;
} SqStack;

  2. 初始化

    void InitStack(SqStack &S)
{
    S.top=-1;
}

  3. 判栈空

    bool StackEmpty(SqStack S)
{
    if(S.top==-1)
        return true;
    else
        return false;
}

  4. 进栈

    bool Push(SqStack &S,ElemType e)
{
    if(S.top==MaxSize-1)
        return false;
    S.data[++S.top]=e;
    return true;
}

  5. 出栈

    bool Pop(SqStack &S,ElemType &e)
{
    if(S.top==-1)
        return false;
    e=S.data[top--];
    return true;
}

  6. 读栈顶元素

    bool GetTop(SqStack S,ElemType &e)
{
    if(S.top==-1)
        return false;
    e=S.data[top];
    return true;
}

2. 共享栈

在一段连续空间首和尾各开辟一个栈，top1=-1时1号栈为空，top2=MaxSize时2号栈为空，当两个栈顶指针相邻时两个栈满

3. 带头结点的链栈

  1. 存储结构

    typedef struct Linknode
{
    ElemType data;
    struct Linknode *next;
} LNode,*LiStack;

  2. 初始化

    bool InitStack(LiStack &p)
{
    p=(LNode *)malloc(sizeof(LNode));
    p->next=NULL;
    return true;
}

  3. 进栈

    bool Push(LiStack &p,ElemType e)
{
    if(p==NULL)
        return false;
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}

  4. 出栈

    bool Pop(LiStack &p,ElemType &e)
{
    if(p==NULL||p->next==NULL)
        return false;
    LNode *s=p->next;
    e=s->data;
    p=s->next;
    free(s);
    return true;
}

  5. 判栈空

    bool StackEmpty(LiStack p)
{
    if(p==NULL)
        return false;
    if(p->next==NULL)
        return true;
    else
        return false;
}

  6. 读栈顶元素

    bool GetTop(LiStack p, ElemType &e)
{
    if(p==NULL||p->next==NULL)
        return false;
    e=p->next->data;
    return true;
}

4. 不带头结点的链栈

  1. 存储结构

    typedef struct Linknode
{
    ElemType data;
    struct Linknode *next;
} LNode,*LiStack;

  2. 进栈

    bool Push(LiStack &p,ElemType e)
{
    if(p==NULL)
    {
        p=(LNode *)malloc(sizeof(LNode));
        p->data=e;
        p->next=NULL;
    }
    else
    {
        LNode *s=(LNode *)malloc(sizeof(LNode));
        s->data=e;
        s->next=p;
        p=s;
    }
    return true;
}

  3. 出栈

    bool Pop(LiStack &p,ElemType &e)
{
    if(p==NULL)
        return false;
    else
    {
        LNode *s=p->next;
        e=p->data;
        free(p);
        p=s;
    }
    return true;
}

  4. 判栈空

    bool StackEmpty(LiStack p)
{
    if(p==NULL)
        return true;
    else
        return false;
}

  5. 读栈顶元素

    bool GetTop(LiStack p, ElemType &e)
{
    if(p==NULL)
        return false;
    e=p->data;
    return true;
}

二、栈的应用

1. 括号匹配

2. 表达式求值

  1. 中缀表达式与前后缀表达式的互化

    中缀表达式化后缀表达式遵循左优先，化前缀表达式遵循右优先

  2. 构造后缀表达式

    使用符号栈

  3. 后缀表达式求值

    使用符号栈与数据栈

3. 递归

  1. 原理

    即我自己调用我自己

  2. 应用

    斐波那契数列

  3. 应用原理

    系统为每一层的返回点、局部变量、传入实参等开辟了递归工作栈来进行数据存储。

三、队列

1. 顺序队列

  1. 存储结构

    #define MaxSize 10
typedef struct Linknode
{
    ElemType data[MaxSize];
    int front,rear;
} SqQueue;

  2. 初始化

    void InitQueue(SqQueue &Q)
{
    Q.front=Q.rear=0;
}

  3. 入队

    bool EnQueue(SqQueue &Q,ElemType e)
{
    if(Q.rear==MaxSize-1)
        return false;
    Q.data[Q.rear++]=e;
    return true;
}

  4. 出队

    bool DeQueue(SqQueue &Q,ElemType &e)
{
    if(Q.rear==Q.front)
        return false;
    e=Q.data[Q.front++];
    return true;
}

  5. 队列判空

    bool QueueEmpty(SqQueue Q)
{
    if(Q.front==Q.rear)
        return true;
    else
        return false;
}

  6. 读队头元素

    bool GetHead(SqQueue Q,ElemType &e)
{
    if(Q.rear==Q.front)
        return false;
    e=Q.data[Q.front];
    return true;
}

2. 循环队列

  1. 存储结构

    #define MaxSize 10
typedef struct Linknode
{
    ElemType data[MaxSize];
    int front,rear;
} SqQueue;

  2. 初始化

    void InitQueue(SqQueue &Q)
{
    Q.front=Q.rear=0;
}

  3. 入队

    bool EnQueue(SqQueue &Q,ElemType e)
{
    if((Q.rear+1)%MaxSize==Q.front)
        return false;
    Q.data[Q.rear]=e;
    Q.rear=(Q.rear+1)%MaxSize;
    return true;
}

  4. 出队

    bool DeQueue(SqQueue &Q,ElemType &e)
{
    if(Q.rear==Q.front)
        return false;
    e=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;
    return true;
}

  5. 队列判空

    bool QueueEmpty(SqQueue Q)
{
    if(Q.front==Q.rear)
        return true;
    else
        return false;
}

  6. 读队头元素

    bool GetHead(SqQueue Q,ElemType &e)
{
    if(Q.rear==Q.front)
        return false;
    e=Q.data[Q.front];
    return true;
}

3. 链队

  1. 存储结构

    #define MaxSize 10
typedef struct LinkNode
{
    ElemType data;
    struct LinkNode *next;
} LinkNode;
typedef struct
{
    LinkNode *front,*rear;
} LinkQueue;

  2. 初始化

    void InitQueue(LinkQueue &Q)
{
    Q.front=Q.rear=(LinkNode *)malloc(sizeof(LinkNode));
    Q.front->next=NULL;
}

  3. 入队

    bool EnQueue(LinkQueue &Q,ElemType e)
{
    LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
    s->data=e;
    s->next=NULL;
    Q.rear->next=s;
    Q.rear=s;
    return true;
}

  4. 出队

    bool DeQueue(LinkQueue &Q,ElemType &e)
{
    if(Q.front==Q.rear)
        return false;
    LinkNode *s=Q.front->next;
    e=s->data;
    Q.front->next=s->next;
    if(s==Q.rear)
        Q.rear=Q.front;
    free(s);
    return true;
}

  5. 队列判空

    bool IsEmpty(LinkQueue Q)
{
    if(Q.front==Q.rear)
        return true;
    else
        return false;
}

  6. 读队头元素

    bool GetHead(LinkQueue Q,ElemType &e)
{
    if(Q.front==Q.rear)
        return false;
    e=Q.front->next->data;
    return true;
}

4. 双端队列

  1. 普通双端队列

    两端皆可入队出队

  2. 输出受限的双端队列

    队头可入队出队，队尾只能入队

  3. 输入首先的双端队列

    对头可入队出队，队尾只能出队

四、队列的应用

1. 层次遍历

  1. 树的层次遍历

    详见 《树》

  2. 图的层次遍历

    详见 《图》

2. 计算机中的应用

  1. 任务队列

    详见 《操作系统》

  2. 进程队列

    详见 《操作系统》

  3. 流量控制窗口

    详见 《计算机网络》

BeZer0
关注
专栏目录
数据结构栈和队列试题及答案
11-26
队列和栈都是运算受限的线性表，只允许在表的一端进行特定的插入和删除操作，该说法正确。 18. **栈和队列的基本属性** 栈和队列都是线性表，但它们分别采用了LIFO和FIFO的规则来约束插入和删除操作，该说法正确...
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 24万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
C语言-栈和队列
m0_73605503的博客
07-22 1244
欢迎来到HanLop博客的C语言数据结构初阶系列。在之前的文章中，我们详细介绍了链表及其操作方法。在本篇文章中，我们将深入探讨栈和队列这两种常见的数据结构。栈和队列虽然都是线性数据结构，但它们在数据的存取方式上有着显著的区别。栈是一种后进先出（LIFO, Last In First Out）的数据结构，而队列则是一种先进先出（FIFO, First In First Out）的数据结构。通过理解和掌握这两种数据结构，您将能更有效地管理数据，并为后续更复杂的数据结构和算法的学习打下坚实的基础。让我们一起开始探
【数据结构】栈和队列
小羊的博客
07-12 2569
栈超超超详解
【数据结构】栈和队列超详细讲解
Become Mad的博客
05-27 2091
我们已经学习了顺序表、链表、数组等数据结构，今天我们再来认识一下栈和队列两种新的数据结构，一起来看看吧~
JavaScript栈和队列
qq_44741577的博客
01-31 947
栈是一种特殊的线性表，仅能在线性表的一端操作，栈顶允许操作，栈底不允许操作。**栈的特点是：**先进后出，或者说是后进先出，从栈顶放入元素的操作叫入栈，取出元素叫出栈。栈的受限性体现在只允许在栈顶插入和删除，因此出栈和入栈都是在栈顶。
栈和队列的转化
xiaobai230811的博客
12-17 1209
栈与队列的相互转换栈和队列是两种基本的数据结构，它们在许多算法和程序中都有应用。虽然栈和队列在概念上是完全不同的，但是我们可以使用两个栈来实现一个队列，或者使用两个队列来实现一个栈。这种转换在某些情况下可能非常有用，例如，当我们的编程环境只提供了栈或队列的实现，但我们需要使用另一种数据结构时。在这篇博客中，我们将详细介绍如何使用两个栈来实现一个队列，以及如何使用两个队列来实现一个栈。我们将提供详细的代码示例，并解释每个函数的工作原理。提示：以下是本篇文章正文内容，下面案例可供参考。
栈和队列的概念
stormsunshine的博客
04-14 4246
文章目录栈、队列和双端队列栈队列双端队列Java 中的栈、队列和双端队列单调栈和单调队列二叉堆和优先队列二叉堆优先队列 栈、队列和双端队列 栈和队列是常见的数据结构。栈的特点是后进先出，添加元素、删除元素和查看元素都在栈顶操作。队列的特点是先进先出，添加元素在队尾操作，删除元素和查看元素在队首操作。 双端队列比栈和队列更加灵活，可以在双端队列的两端添加元素、删除元素和查看元素。 栈、队列和双端队列都满足每次添加元素、删除元素和查看元素的时间复杂度是 O(1)O(1)O(1)。 栈、队列和双端队列都可以基于数
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
栈和队列原理
qq_43697646的博客
01-24 770
栈和队列是STL库里面的两个数据结构。STL有多个版本，知道STL的具体版本才能知道对应的栈和队列的实现原理。 三个常见的STL版本： （1）HP STL HP STL是C++ STL的第一个实现版本，而且开放源代码，其他版本的C++ STL一般是以HP STL为蓝本实现的。 （2）P.J.Plauger STL 由P.J.Plauger参照HP STL实现，被被Visual C++编译器所采用，不是开源的。 （3）SGI STL 由Silicon Graphics Computer Syst
C语言中栈和队列实现表达式求值的实例
08-29
C语言中栈和队列实现表达式求值的实例 栈和队列是数据结构中两个非常重要的概念，它们在计算机科学和编程语言中有着广泛的应用。栈和队列可以用来实现表达式求值，下面我们将通过C语言来实现栈和队列实现表达式求值...
Python实现栈和队列的简单操作方法示例
09-18
本篇文章将深入探讨Python中如何实现栈（Stack）和队列（Queue）这两种基础数据结构。 栈是一种后进先出（Last In, First Out, LIFO）的数据结构，常用于临时存储和快速访问数据。在Python中，由于列表（List）的...
利用栈和队列实现迷宫
06-20
"利用栈和队列实现迷宫" 通过栈和队列两种不同的方法来实现迷宫问题。队列方法求出的迷宫路径是最短路径。迷宫问题是指在一个迷宫中找到从起点到终点的路径。这里我们使用栈和队列两种数据结构来解决这个问题。 栈...
数据结构之存储位置
qq_53841892的博客
09-18 395
内存泄漏：如果没有适时释放被动态分配的内存，会导致内存泄露问题。未释放的内存一直占用系统资源，使得系统变慢并最终导致崩溃。内存释放，合理设计算法，避免算法问题导致的内存无线增长，合理设置作用域。这个数组在函数返回后会失效，因此返回的指针指向的是一个未定义的值。//static变量。频繁的使用堆会产生大量的碎片，而栈则不会。int a = 0;Test 函数会有什么样的结果？函数会有什么样的结果？函数会有什么样的结果？函数会有什么样的结果？
数据结构：二叉树（一）
2303_78940834的博客
09-21 737
ps：偷懒了几天，接着更新。
数据结构—树
2301_80151359的博客
09-22 402
在文件系统中，树结构被广泛应用，它通过父结点和子结点之间的关系来表示不同层级的文件和文件夹之间的关联。树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间的关系。若一个结点含有子结点，则这个结点称为其子结点的父结点；如上图：A是B的父结点。以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙。一个结点含有的子树的根结点称为该结点的子结点；1.有一个特殊的结点，称为根结点，根结点没有前驱结点。具有相同父结点的结点互称为兄弟结点(亲兄弟)；
数据结构之堆（优先级队列）
最新发布
2302_77675796的博客
09-22 551
数据结构之堆（优先级队列）
栈和队列操作实现
"该资源是关于栈和队列的数据结构练习，包含C语言实现的代码，涉及栈的入栈、出栈以及队列的入队、出队等基本操作。" 在计算机科学中，栈（Stack）和队列（Queue）是两种基本的数据结构，它们在处理数据时遵循特定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

BeZer0

打赏一杯奶茶支持一下作者吧~~

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

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

打赏作者

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

抵扣说明：

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

余额充值