Data Structure CH3 栈和队列

已于 2022-10-06 23:34:11 修改
阅读量364 收藏
点赞数
分类专栏： DS in XDU 文章标签： 数据结构 c语言
于 2022-10-06 20:14:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lelico_Mo/article/details/127185803
版权

目录

基础知识

栈

顺序栈的表示和实现

顺序栈基础知识

定义类型

 初始化

 判空

入栈

出栈

取栈顶元素

链栈的表示和实现

定义类型

初始化

判空

取栈顶元素

入栈

出栈

栈与递归

队列

队列的顺序表示和实现

顺序队列基础知识

定义类型

循环队列​编辑

循环队列判空判断的三种方法​编辑

初始化

队列长度

 入队

出队

取队头元素

链式表示和实现

​编辑

定义类型

初始化 

销毁链队列

入队

出队

取队头元素

基础知识

栈

顺序栈的表示和实现

顺序栈基础知识

定义类型

//类C语言
#define MAXSIZE 1000
typedef struct
{
    SElemtype *base;
    SElemtype *top;
    int stacksize;
}SqStack;

//C语言
typedef struct SqStack
{
    int* base;
    int* top;
    int stacksize=1000;
}SqStack;

 初始化

//类C
Status InitStack(SqStack &S)
{
    S.base=(SElemType*)malloc(MAXSIZE*sizeof(SElemType));
    //通过栈底指针开辟一块连续的内存空间，S.base存储该连续空间的基地址
    if(!S.base)    exit(OVERFLOW);
    S.top=S.base;//栈顶指针等于栈底指针
    S.stacksize=MAXSIZE;
    return OK;
}

//C
void InitStack(SqStack *S) //S是指向ST的指针变量
{
    S->base=(int*)malloc((S->stacksize)*sizeof(int));//S->base 即 (*S).base
    if(!S->base)    return;
    S->top=S->base;
}
int main()
{
    SqStack ST;
    InitStack(&ST);
    return 0;
}

 判空

//类C
#define TRUE 1
#define FALSE 0
Status StackEmpty(SqStack S)
{
    if(S.top==S.base)
        return TRUE;
    else
        return FALSE;
}

//C
int StackEmpty(SqStack S)
{
    if(S.top==S.base)
        return 1;
    else
        return 0;
}

int main()
{
    SqStack L;
    //....
    int a=StackEmpty(L);
    //....
}

栈长(NI)

//类C
int StackLength(SqStack S)
{
    return S.top-S.base;
}

//C
int StackLength(SqStack S)
{
    return S.top-S.base;
}
int main()
{
    SqStack L;
    //....
    int len=StackLength(L);
    //....
}

清空(NI)

//类C
Status ClearStack(SqStack &S)
{
    if(S.base)    S.top=S.base;
    return OK;
}

//C
void ClearStack(SqStack *S)
{
    if(S.base)    S->top=S->base;//S->top 即 (*S).top 即 L.top
}
int main()
{
    SqStack L;
    //....
    ClearStack(&L);
    //....
}

销毁(NI)

Status DestroyStack(SqStack &S)
{
    if(S.base)
    {
        delete S.base;//C语言中free()， 直接将数组空间释放
        S.stacksize=0;
        S.base=S.top=NULL;
    }
    return OK;
}

入栈

先判断是否栈满；存放时先放数据，在移动栈顶指针

扩展栈见PPT P22

//类C
Status Push(SqStack &S, SElemtype e)
{
    if(S.top-S.base==S.stacksize)
        return ERROR;
    *S.top=e;//对S.top解引用
    S.top++;
    //可合并为 *S.top++=e;
    return OK;
}

//C
void Push(SqStack *S, int e)
{
    if(S->top - S->base == S->stacksize)
        return;
    *(S->top)=e;
    S->top ++;
}
int main()
{
    SqStack L;
    //...
    Push(&L,e);
    //...
}

出栈

先判断是否栈空；top指针下移

//类C
Status Pop(SqStack &S, SElemType &e)
{
    if(S.top==S.base)
        return ERROR;
    S.top--;
    e=*S.top; // e=*--S.top;
}

//C
void Pop(SqStack *S, int *e)
{
    if(S->top==S->base)
        return;
    S->top--;
    *e=S->top;
}
int main()
{
    SqStack L;
    //....
    int e;
    Pop(&L, &e);
    //....
}

取栈顶元素

//类C
Status GetTop(SqStack S, SElemType &e)
{
    if(S.top==S.base)    return ERROER;
    e=*(S.top-1);//顺序存储结构，对指针加减就可访问到相邻元素
    return OK;
}
//C
void GetTop(SqStack S, int *e)
{
    if(S->top==S->base)    return;
    *e=*(S->top -1);
}
int main()
{
    SqStack L;
    //....
    int e;
    GetTop(&L,&e);
    //....
}

链栈的表示和实现

定义类型

//类C
typedef struct StackNode
{
    SElemType data;
    struct StackNode* next;
}StackNode, *LinkStack;
LinkStack S;

//C
typedef struct StackNode
{
    int data;
    struct StackNode* next;
}StackNode, *LinkStack;
LinkStack S;

注：

链表的头部做栈顶，并且没必要像单链表那样为了运算方便附加一个头结点。

头指针指向栈顶。

空栈相当于头指针指向空。

基本不存在栈满情况。

初始化

头指针指向空

//类C
void InitStack(LinkStack &S)
{
    S==NULL;
    return OK;
}
//C
void InitStack(LinkStack *S)
{
    (*S)==NULL;
}

主函数中 
InitStack(&L);

判空

头指针为空

//类C
Status StackEmpty(LinkStack S)
{
    if(S==NULL)    return TRUE;
    else    return FALSE;
}
//C
int StackEmpty(LinkStack S)
{
    if(S==NULL)    return 0;
    else    return 1;
}

取栈顶元素

Status GetTop(LinkStack S, SElemType &e)
{
    if(S==NULL)
        return ERROR;
    e=S->data;
    return OK;
}

void GetTop(LinkStack S, int *e)
{
    if(S==NULL)    return;
    *e=S->data;
}
主函数中 GetTop(S,&e);

入栈

链表头插法

//类C
Status Push(LinkStack &S, SElemType e)
{
    LinkStack p=(LinkStack)malloc(sizeof(StackNode));
    p->data=e;
    p->next=S;
    S=p;
    return OK;
}
//C
void Push(LinkStack *S, int e)
{
    LinkStack p=(LinkStack)malloc(sizeof(StackNode));
    p->data=e;
    p->next=*S;
    *S=p;
}

出栈

//类C
Status Pop(LinkStack &S,SElemType &e)
{
    LinkStack p;
    if(S==NULL)    return ERROR;
    e=S->data;
    p=S; 
    S=S->next;
    free(p);
    return OK;
}
//C
void Pop(LinkStack *S, int *e)
//如果只是LinkStack S，那么相当于函数的参数等于L，指向头结点，而无法对头指针操作（地位相同），需要一个指向头指针的指针，才能对头指针进行操作
{
    LinkStack p;
    if(*S==NULL)    return;
    *e=(*S)->data;
    p=(*S);
    (*S)=(*S)->next;
    free(p);
}

主函数中 Pop(&L,&e);

栈与递归

PPT P58始

 

队列

队列的顺序表示和实现

顺序队列基础知识

设数组大小为MAXQSIZE，rear可以=MAXQSIZE，但数组下标不可取MAXQSIZE 

 rear=MAXQSIZE时，依据front是否为0分成两种情况

定义类型

//类C
#define MAXQSIZE 100
typedef struct
{
    QElemType *base;//base指向数组的首元素（基地址）
    int front;//头指针
    int rear;//尾指针
    //叫做指针，但不是指针变量
}SqQueue;

//C
typedef struct
{
    int *base;
    int front;
    int rear;
}SqQueue;

再看循环队列更易理解了：

循环队列

SqQueue Q;
//Q是一个含有指向数组基地址的指针，两个分别标记头尾的下标组成的结构变量
Q.base 就相当于数组的名称
Q.rear 是队尾的下标
Q.base[Q.rear]就访问到了下标为Q.rear的元素

循环队列判空判断的三种方法

以下考虑用少用一个元素空间 

rear永远是指向当前最后有数据一格的下一格，front内只要不为空就存有数据，所以只有当最后一个空格子上存上数据之后rear=front； 

初始化

//SqQueue不是指针类型，对其中元素访问用.不用->
//类C
Status InitQueue(SqQueue &Q)
{
    Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));
    if(!Q.base)    exit(OVERFLOW);
    Q.front=Q.rear=0;
    return OK;
}
//Q.base是一个指针，数组名 通过指针分配空间

//C
void InitQueue(SqQueue *Q) //Q是取Q1的地址，才能对Q1进行操作
{
    (*Q).base=(int*)malloc(MAXQSIZE*sizeof(int));
    if(!(*Q).base)    return;
    (*Q).front=(*Q).rear=0;
}

int main()
{
    SqQueue Q1;
    InitQueue(&Q1);

    return 0;
}

队列长度

注意会有Q.rear<Q.front情况，不能用取绝对值解决

 入队

考虑是否队满

(牺牲一个元素位置判断）

//类C
Status EnQueue(SqQueue &Q, QElemType e)
{
    if((Q.rear+1)%MAXQSIZE==Q.front)    return ERRPR;
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1) % MAXQSIZE;
    return OK;
}
//C
void EnQueue(SqQueue *Q, int e)
{
    if(((*Q).rear+1)%MAXQSIZE==(*Q).front)    return;
    (*Q).base[(*Q).rear]=e;
    (*Q).rear=((*Q).rear+1) % MAXQSIZE;
}

int main()
{
    SqQueue Q1;
    //....
    EnQueue(&Q1, e);

}

出队

判断队是否为空

(牺牲一个元素位置判断）

//类C
Status DeQueue(SqQueue &Q, QElemType &e)
{
    if(Q.front==Q.rear)    return ERROR;
    e=Q.base[Q.front];
    Q.front=(Q.front+1)%MAXQSIZE;
    return OK;
}
//C
void DeQueue(SqQueue *Q, int *e)
{
    if((*Q).front == (*Q).rear)    return;
    *e=(*Q).base[(*Q).front];
    (*Q).front=((*Q).front+1)%MAXQSIZE;
}

主函数内 DeQueue(&Q1, &e);

取队头元素

//类C
SElemType GetHead(SqQueue Q)
{
    if(Q.front!=Q.rear)
        return Q.base{Q.front];
}
//C
int GetHead(SqQueue Q)
{
    if(Q.front!=Q.rear)
        return Q.base{Q.front];
}

主函数内 int e=GetHead(Q1);

链式表示和实现

Q.front是指向队头的指针
Q.rear是指向队尾的指针

定义类型

#define MAXQSIZE 100
typedef struct Qnode
{
    QElemType data;
    struct Qnode* next;
}QNode, *QueuePtr;
typedef struct
{
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;
//QueuePtr是struct Qnode*代称，本身就是指针变量，其定义的front，rear都是指针类型
//LinkQueue不是指针类型，访问其内部成员时用.不用->

//C
typedef struct Qnode
{
    int data;
    struct Qnode* next;
}QNode, *QueuePtr;
typedef struct
{
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;

一般而言，LinkQueue类型的结构变量只需要设置一个，因为一个链式队列中只需要一对指针指向队头和队尾。开辟的新节点是QNode类型结构变量

初始化 

Status InitQueue(LinkQueue &Q)
{
    Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
    if(!Q.front)    exit(OVERFLOW);
    Q.front->next=NULL;
}

void InitQueue(LinkQueue *Q)
{
    (*Q).front=(*Q).rear=(QueuePtr)malloc(sizeof(QNode));
    if(!(*Q).front)    exit(OVERFLOW);
    (*Q).front->next=NULL;
}

IniQueuue(&Q1);

初始化操作对比：

队列链式和顺序存储结构：初始化传入的都是存放下标的结构体，或者是存放指向头尾的指针的结构体；并且都分配了连续的空间或第一块节点空间

队列的链式结构初始化时，分配了第一块内存；栈的链式结构不需要头结点，故而没有；但栈的顺序存储结构通过指针分配了连续空间内存

销毁链队列

从队头节点开始，依次释放所有节点（需要先存头结点下一个节点，否则释放完第一个节点之后，下一个节点就找不到了）

Status DestroyQueue(LinkQueue &Q)
{
    while(Q.front)//如果头结点还在
    {
        Q.rear=Q.front->next;
        free(Q.front);
        Q.front=Q.rear;
    }
    return OK;
}
//反正Q.rear也没有用，用它可以少定义一个指针变量

注：free释放指向内存空间地址，指针本身还在

入队

加入到队尾Q.rear后面

链式入队不需判满

Status EnQueue(LinkQueue &Q, QElemType e)
{
    QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
    if(!p)    exit(OVERFLOW);
    p->data=e;
    p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
    return OK;
}

void EnQueue(LinkQueue *Q, int e)
{
    QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
    if(!p)    exit(OVERFLOW);
    p->data=e;
    p->next=NULL;
    (*Q).rear->next=p;
    (*Q).rear=p;
}

EnQueue(&Q1,e);

出队

在队头出队，删除第一个节点。头结点是第一个节点的前驱

链式出队也需要判空

Status DeQueue(LinkQueue &Q, QElemType &e)
{
    if(Q.front==Q.rear)
        return ERROR;
    QueuePtr p;
    p=Q.front->next;
    e=p->data;
    Q.front->next=p->next;
    
    if(Q.rear==p)    Q.rear=Q.front;
    //删之前就只有两个节点，即删除尾结点的情况：将尾指针也指向头指针，都指向头结点
    free(p);
    return OK;
}

void DeQueue(LinkQueue *Q,int *e)
{
    if((*Q).front==(*Q).rear)    return;
    QueuePtr p;
    p=(*Q).front->next;
    *e=p->data;
    (*Q).front->next=p->next;
    
    if((*Q).rear==p)    (*Q).rear=(*Q).front;
    free(p);
}

DeQueue(&Q1, &e);

取队头元素

Status GetHead(LinkQueue Q, QElemType &e)
{
    if(Q.front==Q.rear)    return ERROR;
    e=Q.front->next->data;
    return OK;
}

void GetHead(LinkQueue Q, int *e)
{
    if(Q.front==Q.rear)    return;
    *e=Q.front->next->data;
}

GetHead(Q1,&e);

Lelico_Mo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
栈和队列
Hyh的博客
03-20 476
栈(Stack) 后进先出（LIFO） 栈顶操作 是一个特殊的线性表，是限定仅在一端（通常是表尾）进行插入和删除操作的线性表 表尾（an）称为栈顶Top,表头（a1）称为栈底Base 顺序栈的表示 //顺序栈的表示 #define MAXSIZE 100 typedef struct{ SElemType *base; //栈底指针 SElemType *top; ...
数据结构——链队列
minyuanxiani的专栏
09-05 733
#include using namespace std; typedef struct qnode { int data; struct qnode * next; }Qnode, * Queueptr; // 创建链 Qnode是struct qnode的别名，Queueptr是struct qnode *的别名 typedef
数据结构——栈和队列
杨总的博客
06-05 403
目录3.1栈和队列的定义和特点3.2案例引入3.3栈的实现和操作的实现顺序栈的表示顺序栈初始化顺序栈是否为空顺序表长度清空顺序栈销毁顺序栈顺序栈的入栈顺序栈的出栈链栈的表示链栈的初始化链栈是否为空链栈的入栈链栈的出栈取栈顶元素3.4栈和递归3.5队列的表示和操作的实现顺序队表示链队表示3.6案例分析与实现Status DeQueue(LinkQueue &Q,QElemType &e){if(Q.front==Q.rear) return ERROR;p = Q.front->next;e = p->dat
数据结构与算法基础（王卓）（11）：栈的定义及其基础操作（顺序和链式的初始化、求长度，是否为空，清空和销毁、出栈、压栈），栈与递归
Zz_zzzzzzz__的博客
02-20 715
stack：一堆，一摞;堆；垛;数据结构与算法基础（王卓）（7）：小结：关于链表和线性表的定义及操作_宇 -Yu的博客-CSDN博客（这里写的是线性表的构造形式，也可以写成链表的构造形式） 初始化： 简单操作：（求长度，是否为空，清空和销毁） 在这里，我们很容易产生这样的疑问：关于清空和销毁，我们不是应该把元素一个一个置为NULL吗？？？这里销毁和清空改变的只是指向这个位置的指针的值，可是没有把位置的内容置空（null）啊？？实际原因解释如下：这里我们其实只是让（将）栈回归到（置于）
如何使用JavaScript实现栈与队列
12-11
栈和队列是web开发中最常用的两种数据结构。绝大多数用户，甚至包括web开发人员，都不知道这个惊人的事实。如果你是一个程序员，那么请听我讲两个启发性的例子:使用堆栈来组织数据，来实现文本编辑器的“撤消”操作;...
第3章 栈和队列答案1
08-08
7、(1)满 (2)空 (3)n (4)栈底 (5)两栈顶指针相邻（即值之差的绝对值为1）8、链式存储结构 9、S×SS×S×× 10、data[++top]=
Swift Data Structure and Algorithms azw3
09-26
Swift Data Structure and Algorithms 英文azw3 本资源转载自网络，如有侵权，请联系上传者或csdn删除 本资源转载自网络，如有侵权，请联系上传者或csdn删除
数据结构-栈与队列
01-07
顺序栈的定义2：入栈二、顺序队列1：顺序栈的定义2：入队3：出队三、链队列1：链队列的定义：2：入队3：出队 一、顺序栈 1.顺序栈的定义 #define MaxSize 64 /* const int MaxSize =64; */ typedef int datatype; ...
【精品课件】数据结构与算法 数据结构与C语言 data structure课程 第3章 栈和队列（共150页）.ppt
11-05
数据结构与算法 数据结构与C语言 第3章 栈和队列（共150页）.ppt 数据结构与算法 数据结构与C语言 第4章 串、数组和广义表（共66页）.ppt 数据结构与算法 数据结构与C语言 第5章 树和二叉树（共95页）.ppt 数据结构...
[数据结构]学习笔记：链队
weixin_46285081的博客
10-16 143
定义 typedef struct QNode{ QElemType data; struct QNode *next; }QNode,QueuePtr; typedef struct{ QueuePtr front; //队头指针 QueuePtr rear; //队尾指针 }LinkQueue; 初始化 带头结点 Status InitQueue(LinkQueue &Q){ //构造一个空队列 Q.front=Q.rear = new QNode; //生成新结点作为头
队列，循环队列，链队列的基础操作
diviner_s的博客
02-03 3881
队列 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 队列的抽象数据类型定义： ADT Queue{ 数据对象：D={ai | ai∈ElemSet，i=1，2，…,n,n≥0} 数据关系：R={< a(i-1) , ai ...
数据结构严薇敏——队列的顺序存储（C语言）
Attention_0的博客
07-28 536
和栈相反，队列是一种先进先出的线性表。只能在表的一端进行插入，另一端进行删除。（类似与我们排队买东西，先到先得） 队列中，允许插入的一端叫做队尾，允许删除的一端叫队头。 代码实现 ： 顺序数据结构定义为： typedef int ElemType; typedef struct SqQueue { ElemType data[MAX_SIZE]; int size; ...
数据结构-栈的灵活表示方式(栈顶指针和栈底指针)
10-22 9469
在前面的文章中我们已经学习过基本栈的概念和操作，我们是通过“标准方式”数组的形式模拟了一个栈；本篇文章我将通过一种更灵活的方式定义栈以及实现栈的基本操作，废话不多说，直接上代码（注释都有说明哦） //栈的灵活表示法，通过定义栈顶指针和栈底指针的方式 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define ElementType ...
数据结构C语言—线性表【栈】动态顺序栈（malloc动态分配实现）【2021-07-05】
TDTX博客
07-05 375
数据结构C语言—线性表【栈】动态顺序栈（malloc动态分配实现）SqStackMalloc.hSqStackMalloc.cmain.c运行结果示例 SqStackMalloc.h #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define NOEXIST -1 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE 1 #define O
ESP和EBP 栈顶指针和栈底指针
hutao1101175783的专栏
04-27 3531
1）ESP：栈指针寄存器(extended stack pointer)，其内存放着一个指针，该指针永远指向系统栈最上面一个栈帧的栈顶。 （2）EBP：基址指针寄存器(extended base pointer)，其内存放着一个指针，该指针永远指向系统栈最上面一个栈帧的底部。 【本次重点内容：了解几个常见的寄存器名字，记住eax一般用来保存函数的返回值，记住esp是栈顶指针寄存器，ebp是栈底指针寄存器。】 ESP 中的指针将一直指向这个新位置, 所以 ESP 中的地址数据是动态的. ...
数据结构逻辑
最新发布
qq_42129915的博客
06-10 279
1、线性关系2：树型关系3：图像关系。
【数据结构】 -- 堆 （堆排序）（TOP-K问题）
prettyxian的博客
06-09 1023
要学习堆，首先要先简单的了解一下二叉树，二叉树是一种常见的树形数据结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的应用非常广泛，在后面我会详细介绍。满二叉树：除了叶子结点外，每个结点都有两个子结点一个深度为k的满二叉树有2的k次方减一个节点。完全二叉树：除了最底层可能不是满的外，其它每一层从左到右都是满的。满二叉树是完全二叉树的子集，满二叉树一定是完全二叉树，但完全二叉树不一定是满二叉树。堆就是一种完全二叉树。
【算法】常用排序算法（插入排序、希尔排序、堆排序、选择排序、冒泡排序、快速排序、归并排序、计数排序）超详细
abcwyffff的博客
06-09 991
排序算法是数据结构相关知识中非常重要的一节，相信很多小伙伴对这部分知识一知半解。那么接下来，小编就要带领大家一起来进行对排序算法的深入剖析学习，希望本篇文章能够使你有所收获！
栈和队列的空间复杂度
08-23
- *1* *2* *3* [数据结构之栈、队列](https://blog.csdn.net/sdsxdqg/article/details/103389790)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值