数据结构第三章 栈和队列

最新推荐文章于 2023-03-01 17:39:06 发布
置顶 最新推荐文章于 2023-03-01 17:39:06 发布
阅读量239 收藏
点赞数 1
分类专栏： 数据结构C语言版 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67130295/article/details/127725644
版权

前言：

        栈和队列可以称为操作受限的线性表。

目录：

一、栈

     1.栈的定义

     2.栈的表示和实现

        ①  顺序栈

        ②双向栈

       ③链栈

二、队列

     1.队列的定义

    2.队列的表示和实现

        ①循环队列

一、栈

     1.栈的定义

        限定仅在表尾进行插入和删除的线性表。表尾端称为栈顶 (top)，表顶端称为栈底 (bottom)。a1称为栈底元素，an称为栈顶元素。
        如图所示，我们不难看出：栈是一个“后进先出，先进后出”的线性表。

         注：栈除了存储数据元素外，还记录了数据元素入栈的次序。(考试必考点)
例：现有元素a、b、c、d、e、f 依次进栈，允许出栈、退栈操作交替进行。但不允许连续三次进行退栈操作，则不可能得到的出栈序列是：
        A. dcebfa        B. cbdaef        C. bcaefd        D.afedcb
解析：D选项中当 f 入栈前有 bcde 依次出栈，超过了限定条件连续三次退栈操作。

     2.栈的表示和实现

        ①  顺序栈

//顺序栈的定义
typedef char SElemType;    //这里char根据具体变量类型进行更改
#define STACK_INIT_SIZE 100;
#define STACKINCREMENT 10;
typedef struct {
    SElemType *base;    //栈底指针
    SElemType *top;     //栈顶指针
    int stacksize;      //存储容量
} SqStack;

//顺序栈的初始化
#define OVERFLOW -1;
void InitStack(SqStack *S)
{
    S->base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
    if(!S->basse){    //分配空间失败，则进行报错并结束程序
        printf("分配空间失败！");
        exit(OVERFLOW);
    }
    S->top = S->base;
    S->stacksize = STACK_INIT_SIZE;
}

//顺序栈的入栈操作
void Push(SqStack *S, SElemType e)
{
    if((S->top - S->base) >= S->stacksize){    //栈满判定    
        S->base = (SElemType *)realloc(S->base,
             (S->stacksize+STACKINCREMENT)*sizeof(SElemType));
        if(!S->basse){    //分配空间失败，则进行报错并结束程序
            printf("分配空间失败！");
            exit(OVERFLOW);
        }
        S->top = S->base + S->stacksize;
        S->stacksize = S->stacksize + STACKINCREMENT; 
    }
    *S->top++ = e;
}

//顺序栈的出栈操作
void Pop(SqStack *S, SElemType *e)
{
    if(S->top == S->base){
        printf("栈空！");
        return -1;
    }
    *e = *--S->top;
}

        栈底指针指向分配空间的第一个单元，栈顶指针指向栈顶元素后的一个单元。
        上溢：当栈满时再做入栈运算必定产生空间溢出；
        下溢：当栈空时再做出栈运算也将产生溢出。

        ②双向栈

        在一个程序中同时使用两个数据类型相同的栈，可以考虑采用双向栈。

//双向栈的定义
#define STACKSIZE 100;
typedef char SElemType;
typedef struct {
    int top[2];        //栈顶指针
    SElemType *base;   //存储基址
    int stacksize;
}DqStack;

//双向栈的初始化
void InitStack(DqStack *S)
{
    S->top[0] = -1;
    S->top[1] = STACKSIZE;
    S->stacksize = STACKSIZE;
    S->base = (SELemType *)malloc(STACKSIZE*sizeof(SElemType));
}

//双向栈的进栈操作
#define ERROR -1
void Push(DqStack *S, int e, int i)     //进i号栈
{
    if(S->top[1] - S->top[0] == 1){
        printf("栈满！");
        return ERROR;
    }
    switch(i){
        case 0:
            ++S->top[0];
            S->base[S->top[0]] = e;
            break;
        case 1:
            --S->top[1];
            S->base[S->top[1]] = e;
            break;
        default:
            break;
    }
}

//双向栈的出栈操作
#define ERROR -1;
void Pop(DqStack *S, int *e, int i)     //出i号栈
{
    switch(i){
        case 0:
            if(S->top[0] == -1){
                printf("栈空！");
                return ERROR;
            }
            *e = S->base[--S->top[0]];
            break;
        case 1:
            if(S->top[1] == STACKSIZE){
                printf("栈空！");
                return ERROR;
            }
            *e = S->base[++S->top[1]];
            break;
        default:
            break;
    }
}

       ③链栈

//链栈的定义
typedef struct SNode{
    SElemType data;
    struct SNode *next;
} *LinkStack;

二、队列

     1.队列的定义

        限定在表的一端进行插入，在表的另一端进行删除的线性表。表插入端称为队尾；表删除端称为队头。a1称为队头元素，an称为队尾元素。
        如图所示，我们不难看出：队列是一个“先进先出，后进后出”的线性表

        注：跟栈一样，我们仍然可以从队列中得到元素的入队次序。(考试必考点)
例：某队列允许在两端进行入队操作，但仅允许在一端进行出队操作，若元素a，b，c，d，e依次入队列后再进行出队列，则不可能得到出对序列是：
        A. bacde         B. dbace        C. dbcae        D. ecbad

    2.队列的表示和实现

        ①循环队列

//循环队列的定义
typedef char QElemType;
#define MAXQSIZE 100
typedef struct {
    QElemType *base;    //存储基址
    int front;          //头指针
    int rear;           //尾指针
} SqQueue;

//循环队列的初始化
#define OVERFLOW -1;
void InitQueue(SqQueue *Q)
{
    Q->base = (QElemType *)malloc(MAXQSIZE*sizeof(QElemType));
    if(!Q->base){
        printf("分配空间失败！");
        exit(OVERFLOW);
    }
    Q->front = Q->rear = 0;
}

//循环队列的入队操作
#define ERROR -1;
void EnQueue(SqQueue *Q, QElemType e)
{
    if((Q->rear+1)%MAXQSIZE == Q->front){
        printf("队满！");
        return ERROR;
    }
    Q->base[Q->rear] = e;
    Q->rear = (Q->rear+1) % MAXQSIZE;
}

//循环队列的出队操作
void DeQueue(SqQueue *Q, QElemType *e)
{
    if(Q->front == Q->rear){
        printf("队空！");
        return ERROR;
    }
    *e = Q->base[Q->front];
    Q->front = (Q->front + 1) % MAXQSIZE;
}

        ②链栈

//链队的定义
typedef char QElemType;
typedef struct QNode {
    QElemType data;        //数据域
    struct QNode *next;    //指针域
} QNode, *QueuePtr;
typedef struct {
    QueuePtr front;    //队头指针
    QueuePtr rear;     //队尾指针
} LinkQueue;

//链队的初始化
#defint OVERFLOW -1;
void InitQueue(LinkQueue *Q)
{
    Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));
    if(!Q->front){
        printf("分配空间失败！");
        exit(OVERFLOW);
    }
    Q->front->next = NULL;
}

//链队的入队操作
void EnQueue(LinkQueue *Q, QElemType e)
{
    QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
    if(!p){
        printf("分配空间失败！");
        exit(OVERFLOW);
    }
    p->data = e;
    p->next = NULL;
    Q->rear->next = p;
    Q->rear = p;
}

//链队的出队操作
#define ERROR -1;
void DeQueue(LinkQueue *Q, QElemType *e)
{
    if(Q->rear == Q->front){
        printf("队空！");
        return ERROR;
    }
    QueuePtr p = Q->front->next;
    *e = p->data;
    Q->front->next = p->next;
    if(Q->rear ==p) Q->rear = Q->front;
}

爱睡觉的panda
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构第三章栈和队列.pdf
11-12
"数据结构第三章栈和队列" 本章节主要介绍了栈和队列这两种基本数据结构的概念、实现和应用。 一、栈的基本概念 栈是一种后进先出（Last In First Out，LIFO）的数据结构，仅允许在栈顶插入或删除元素。栈的基本...
if (!S.base)exit(OVERFLOW)是什么意思
weixin_45963815的博客
04-11 1万+
在学习数据结构栈这一部分的时候，有一句代码 if (!S.base)exit(OVERFLOW)； 搞不懂什么意思 exit是c++程序的退出函数，声明为void exit(int value) 其功能是退出当前的程序，并将参数value返回主调进程 OVERFLOW为math.h的一个宏定义，其值为3。含义为运算过程中出现了上溢，即运算结果超出了运算变量所能存储的范围。 所以，exit(OVER...
数据结构之队列
qq_40245237的博客
09-15 92
一.循环队列的顺序实现 1.1原理：借助于数组实现，原理结构如下： 1.2程序部分： struct Queue { int data[MAX]; int front, rear; }; int init_Queue(Queue *s) { s->fr...
exit的用法
yyy_zxc的博客
09-12 4265
exit用于在程序运行的过程中随时结束程序，exit的参数是返回给OS的。exit是结束一个进程，它将删除进程使用的内存空间，同时把错误信息返回父进程,而return是返回函数值并退出函数。所以，exit(OVERFLOW)的含义就是，退出程序，并返回OVERFLOW的值给主调进程。其标准的使用范围为，当程序运算出现上溢时，退出程序并报错给主调进程。原文链接：https://blog.csdn.net/weixin_45963815/article/details/105455178。
c语言顺序线性表的实现
pakai的博客
03-01 816
/顺序线性表的结构体//数据地址//数据表长度//当前分配的存储容量}List;#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量#define LISTINCREMENT 10 //线性表存储空间的分配增量#define ElemType int //自定义数据类型//定义状态码类型#define OK 1 //完成#define OVERFLOW 0 //失败#define ERROR 0 //错误。
数据结构（C语言版）第三章 栈和队列-整理-队列
Glitter_N的博客
11-19 151
队列 允许插入的一端叫做队尾 允许删除的一段叫做队头 先进先出的线性表（FIFO） 链队列： #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int QElemType; typedef int Status; //-------单链队列——队列的链式存储结构-------- typedef struct QNode{ QElemType
数据结构第三章栈和队列3.3-3.4
最新发布
11-23
数据结构第三章栈和队列3.3-3.4
数据结构第三章栈和队列3.1-3.2
11-23
数据结构第三章栈和队列3.1-3.2
数据结构第三章栈和队列3习题.pdf
07-29
数据结构第三章栈和队列习题 在本节中，我们将讨论栈和队列这两种基本数据结构，通过习题来深入了解它们的实现和应用。 1. 栈的实现 栈是一种后进先出（LIFO）的数据结构，栈顶元素是最新添加的元素。栈的实现...
数据结构 第3章 栈和队列.ppt
06-17
数据结构-栈和队列 栈是一种特殊的线性表，它限定仅在表尾进行插入和删除操作。栈的顶端称为栈顶，栈的底端称为栈底。栈的特点是后进先出（LIFO）或先进后出（FILO）。 栈的抽象数据类型定义（ADT）： ADT Stack...
exit（overflow）
you_best_honor的博客
10-24 4581
**exit（overflow）**意思是越界溢出，常用于C/C++中
C++退出函数exit
热门推荐
08-14 3万+
exit为C++的退出函数，声明于stdlib.h中，对于C++其标准的头文件为cstdlib,声明为 void exit(int value); exit的功能为，退出当前运行的程序，并将参数value返回给主调进程。 在main中return v;的效果 与exit(v);相同。 OVERFLOW为math.h中的一个宏定义，其值为3。含义为运算过程中出现了上溢，即运算结果超出了运算变量
数据结构——顺序表示
shc003218的博客
07-10 320
王卓老师数据结构课程-线性表的顺序表示代码小结
敲线性表代码时遇到的问题（C++)【exit,return】
jikenvhai的博客
04-28 1372
1：exit(OVERFLOW) ①exit简介 为C++的退出函数，声明于stdlib.h中，对于C++其标准的头文件为cstdlib,声明为 void exit(int value); exit(0)：运行正常退出程序 exit(1)：运行异常退出退出程序，返回值1是返回给操作系统的 exit(x)（x不为0）：都表示异常退出 exit的功能为，退出当前运行的程序，并将参数value返回给主调进程。 OVERFLOW为math.h中的一个宏定义，其值为3。含义为运算过程中出现了上溢，即运算结果
2.2线性表的顺序表示和实现
IT1995的博客
01-26 5722
2.2线性表的顺序表示和实现
exit(OVERFLOW) error: expected ')' before ';' token|
weixin_43873389的博客
10-27 1389
将overflow改为-1
数据结构-队列
weixin_49895102的博客
04-10 862
#include<stdio.h> #include<stdlib.h> //用顺序结构实现队列，同时通过取模运算避免出现假溢出的情况（我们称之为循环队列） //队列满：（rear+1)mod MAXSIZE == front; 队列空: rear=front //循环队列的类型定义 typedef struct { QueueElementType element[MAXSIZE]; int front; int rear; }SeqQueue; //初始化一个.
C语言队尾rear算法,数据结构（C语言版）课后习题答案
weixin_42099815的博客
05-24 1412
}(2) 判队空int EmptyQueue( LinkQueue *Q){ //判队空。当头结点的next指针指向自己时为空队 return Q->rear->next->next==Q->rear->next; }(3) 入队void EnQueue( LinkQueue *Q, Datatype x) { //入队。也就是在尾结点处插入元素 QueueNode...
数据结构栈和队列课后习题头歌
10-18
根据提供的引用内容，我可以为您解答数据结构栈和队列课后习题的相关问题。 根据引用中的内容，我们可以知道栈和队列都是线性结构，栈是一种特殊的线性表，允许插入和删除运算的一端称为栈顶，不允许插入和删除运算...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

爱睡觉的panda

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

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

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

打赏作者

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

抵扣说明：

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

余额充值