栈和队列学习小结

已于 2023-04-08 20:31:37 修改
阅读量327 收藏
点赞数
文章标签： 学习
于 2023-01-28 22:05:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57068311/article/details/128770406
版权

#栈

一种操作受限的特殊的线性表，可以用顺序表和链表来表示栈，普通的顺序表可以在任意位置插入或删除元素，但是栈这一数据结构只能在端点进行插入和删除，其运算规则是后进先出，生活中有很多栈的模型例如手枪弹夹，他就是一颗一颗子弹压入弹夹中，最后压入的子弹最先打出去，这也是遵循了后进先出的原则，因此对于栈的插入我们称为压栈或者入栈，对于栈中元素删除的操作我们称为出栈或者弹栈。通常对栈进行操作都是依靠栈顶指针进行插入和删除。另外在递归操作中，也是用到了栈来存储数据，因为栈的操作特点非常符合递归的原理，递归是先调用函数，再进行值的返回。

在顺序栈中，每次元素入栈后栈顶指针都会向上移动一次，方便下次插入操作。同理，出栈的时候通过栈顶指针删除栈中元素 &x = S.data[S.Top - 1] 

 总结

栈的操作代码实现

 初始化栈  判断栈是否为空 压栈 获取栈顶元素 弹栈

//
// Created by Administrator on 2023/1/26.
//
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>


//初始化栈-出栈
/*
 * 步骤
 * 初始化栈  判断栈是否为空 压栈 获取栈顶元素 弹栈
 */
#define MaxSize 50
typedef int ElemType;
typedef struct{
    ElemType data[MaxSize];
    int top;
}Sqstack;

//初始化栈
void InitStack(Sqstack &S)
{
    S.top = -1;
}
//判断栈是否为空
bool StackEmpty(Sqstack *S)
{
    if(S->top == -1)
    {
        return true;
    }
    return false;
}

//压栈
bool Push(Sqstack &S, ElemType elem)
{
    if(S.top > MaxSize - 1)
    {
        return false;
    }
    S.data[++S.top] = elem;
    return true;
}
//获取栈顶元素
ElemType getNum(Sqstack *S)
{
    bool flag = StackEmpty(S);
    if(flag)
    {
        return -1;
    }
    return S->data[S->top - 1];
}
//弹栈
bool Pop(Sqstack &S,ElemType &n)
{
    if( n > S.top)
    {
        return  false;
    }
    n = S.data[S.top -1];
    return true;
}



int main1() {
    Sqstack S;
    ElemType m;
    //初始化栈
    InitStack(S);
    bool flag;
    flag = StackEmpty(&S);
    if(flag)
    {
        printf("栈是空的\n");
    }
    Push(S,3);
    Push(S,4);
    Push(S,5);
    int n =getNum(&S);//获取栈顶元素
    printf("获取栈顶元素为%d\n",n);

    flag=Pop(S,m);//弹出栈顶元素
    if(flag)
    {
        printf("弹出元素为%d\n",m);
    }
    return 0;

}

链栈

链栈是栈的链表表示形式，只能在链表的头部操作，在我们创建链栈的时候通常这种方向操作更加方便，也更加符合栈的特点。我们通常用头插法和头删法来进行链栈的入栈和出栈操作，链栈的头指针就是栈顶，因此在插入和删除的时候就是用头指针进行操作，并且链栈是不需要头节点的，没有头节点其实操作起来更加的方便，并且也更加适合栈这一数据结构，链表中的空栈相当于头指针指向NULL。

 链栈的操作代码实现

入栈，出栈

//
// Created by Administrator on 2023/1/27.
//
#include <cstdlib>
#include "stdio.h"

typedef int ElemType;
typedef struct Stacknode{
    ElemType data;
    struct Stacknode *next;
}StackNode, *LinkStack;

//  压栈 弹栈

//链栈的初始化
void InitStack1(LinkStack &S)
{
    S = (LinkStack)malloc(sizeof (StackNode));
    S->next = NULL;
}
//链栈的入栈
void Push1(LinkStack S,ElemType n)
{
    StackNode *p = (LinkStack) malloc(sizeof (StackNode));
    //栈只能在栈顶进行操作 所以要用到头插法
    p->data = n;
    p->next = S->next;
    S->next = p;
}
//链栈的出栈
bool Pop1(LinkStack &S,ElemType &n)
{
    //栈顶操作 头删法
    StackNode *p;
    p = S->next;
    if(p==NULL)
    {
        return false;
    }
    n = p->data;
    S->next = p->next;
    free(p);
    return true;
}
//打印链表
void PrintList(LinkStack L)
{
    L = L->next;
    while (L!=NULL)
    {
        printf("%3d",L->data);
        L = L->next;
    }
}
int main()
{
    int x;
    LinkStack S;
   InitStack1(S);
    Push1(S,1);
    Push1(S,2);
    Push1(S,3);
    PrintList(S);
    Pop1(S,x);
    PrintList(S);

    return 0;
}

#队列

队列其实是一种操作受限的特殊线性表，也是一对一的，其特殊性就在于他只能在两端进行操作，在表的一端插入，在表的另一端删除。向队列中插入元素称为入队或进队，删除元素称为出队或者离队，队列遵循的是先进先出原则，与我们日常生活中的队列模型是一样的。

 同样的队列的实现也可以用顺序表实现和链表实现。

用顺序表实现的队列

//
// Created by Administrator on 2023/1/27.
//
//
// Created by Administrator on 2023/1/26.
//
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>


//初始化队列
/*
 * 步骤
 * 初始化队列  判断队列是否为空 入队 获取队头元素 出队
 */
#define MaxSize 3
typedef int ElemType;
typedef struct{
    ElemType data[MaxSize];
    ElemType front;
    ElemType rear;
}SqQueque;

//初始化队列
void InitQueque(SqQueque &Q)
{
    Q.front = 0;
    Q.rear = 0;
}

//判断队列是否为空
bool QuequeEmpty(SqQueque *Q)
{
    if(Q->front == Q->rear)
    {
        return true;
    }
    return false;
}

//入队
bool EnQueque(SqQueque &Q,ElemType n)
{
    if(Q.rear == MaxSize) //入队先判断队列是否满，用尾指针来判断队列是否已经满了
    {
        return false;
    }
    Q.data[Q.rear]  = n;
    Q.rear++;
    return true;
}

ElemType getFrontElem(SqQueque *Q)
{
    bool flag = QuequeEmpty(Q);
    if(flag)
    {
        return -1;
    } else{
        return Q->data[Q->front];
    }

}

//出队
bool OutQueque(SqQueque &Q,ElemType &n)
{
    if(Q.front == Q.rear) // 判断队列是否为空，当首指针与尾指针相等的时候 队列为空。
    {
        return false;
    }
    n = Q.data[Q.front];
    Q.front++;
    return true;
}

int main2() {
    SqQueque Q;
    int s;
    int n = 0;
    InitQueque(Q); //初始化队列
    bool flag = QuequeEmpty(&Q);
    if(flag)
    {
        printf("队列为空\n");
    }
    EnQueque(Q,3);//入队
    EnQueque(Q,4);
    EnQueque(Q,5);
    s = getFrontElem(&Q);
    printf("队头元素为%d\n",s);
    OutQueque(Q,n);
    printf("元素出队，数值为%d\n",n);
    s = getFrontElem(&Q);
    printf("队头元素为%d\n",s);
    bool  flag1  = EnQueque(Q,6);
    if(!flag1)
    {
        printf("队列发生上溢出");
    }


    return 0;

}

然而这种形式的队列有一个缺点那就是会发生溢出，就是当尾指针大于设置的MaxSize时，如果这个时候你用头指针进行对前面元素的删除的话，这个时候队列是没有满的，但是由于是靠尾指针来进行插入操作但是此时尾指针已经判定溢出，因此虽然这个时候队列没有满但是不可以再往队列里面存放数据了。

这个时候 我们就需要引入循环队列，循环队列的特点就是首尾相连，循环队列的特性很好的解决这一问题,将空间重复的反复的应用。因此我们在移动首尾指针的时候就可以利用取模运算来实现这一特性，当你的首尾指针移动的时候也就是 rear + 1 % MaxSize, front +1 % MaxSize

 这

 但是如果使用上述条件虽然解决了空间浪费的问题，但是当尾指针填满最后一个空间之后再次移动尾指针，他会与首指针指向同一个空间，此时队列空与队列满的判断条件就相等了，因此为了区分判断队空与队满，我们有以下三个解决方法 ，此时如果少用一个元素空间来区分的话，那么当长度达到MaxSize-1的时候，就可以作为队满的判断条件，也就是

(rear +1)%MaxSize == front因此这样就很好区别队满与队空的判断条件了

第二种方式 不浪费存储空间还解决上溢的方法

//
// Created by JustinLiang on 2023/4/1.
//
#include <stdio.h>
#include <cstdlib>

typedef int Elemtype;
#define Maxsize 6
//顺序存储队列
typedef struct {
    Elemtype data[Maxsize];
    Elemtype rear;
    Elemtype front;
    int size;
}SqQueQue;


//初始化队列
void InitSqQueque(SqQueQue &Q)
{
    Q.front = 0;
    Q.rear = 0;
    Q.size = 0;
}

//循环队列的判空
bool QueIsEmpty(SqQueQue Q)
{
    if(Q.size == 0)
    {
        return true;
    }
    return false;
}

//入队
bool EnQueQue(SqQueQue &Q)
{
    //判满
    if(Q.size == Maxsize)
    {
        return false;
    }
    int x;
    printf("请输入入队的值\n");
    scanf("%d",&x);
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear +1) %Maxsize;
    Q.size++;
    return true;
}

//出队
bool DeQueQue(SqQueQue &Q,Elemtype &n)
{
    //判空
    bool flag = QueIsEmpty(Q);
    if(!flag)
    {
        n = Q.data[Q.front];
        Q.front = (Q.front+1) % Maxsize;
        Q.size--;
        return true;
    }
    return false;
}

//获取队头元素
bool getTopElem(SqQueQue Q, Elemtype &n)
{
    if(Q.size == 0)
    {
        return false;
    }
    n = Q.data[Q.front];
    return true;
}
int main()
{
    SqQueQue Q;
    InitSqQueque(Q);

    int n=0;
    int m=0;
    bool flag = QueIsEmpty(Q);
    if(flag)
    {
        printf("队列为空\n");
    }

    for (int i = 0; i < 7 ; ++i) {
        bool flag1 = EnQueQue(Q);
        if(!flag1)
        {
            printf("队列已满不能继续输入\n");
        }
    }
    getTopElem(Q,m);
    printf("此时队头为%d\n",m);
    DeQueQue(Q,n);
    printf("出队元素为%d\n",n);
    getTopElem(Q,m);
    printf("此时队头为%d",m);


}

 第三种方式 设置信号量   删除后设置信号量置为0 插入后信号量置为1 并且队列空或满时头指针与尾指针都相等。

//
// Created by JustinLiang on 2023/4/1.
//
#include <stdio.h>
#include <cstdlib>

typedef int Elemtype;
#define Maxsize 6
//顺序存储队列
typedef struct {
    Elemtype data[Maxsize];
    Elemtype rear;
    Elemtype front;
    int Tag;
}SqQueQue;


//初始化队列
void InitSqQueque(SqQueQue &Q)
{
    Q.front = 0;
    Q.rear = 0;
    Q.Tag = 0;
}

//循环队列的判空
bool QueIsEmpty(SqQueQue Q)
{
    if(Q.front == Q.rear && Q.Tag == 0)
    {
        return true;
    }
    return false;
}

//入队
bool EnQueQue(SqQueQue &Q)
{
    //判满 信号量为1 说明刚刚使用的是插入操作此时如果尾指针与头指针在一起那就说明为满
    if(Q.front == Q.rear && Q.Tag == 1)
    {
        return false;
    }
    int x;
    printf("请输入入队的值\n");
    scanf("%d",&x);
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear +1) %Maxsize;
    Q.Tag = 1;
    return true;
}

//出队
bool DeQueQue(SqQueQue &Q,Elemtype &n)
{
    //判空
    bool flag = QueIsEmpty(Q);
    if(!flag)
    {
        n = Q.data[Q.front];
        Q.front = (Q.front+1) % Maxsize;
        Q.Tag = 0;
        return true;
    }
    return false;
}

//获取队头元素
bool getTopElem(SqQueQue Q, Elemtype &n)
{
    if(Q.front == Q.rear && Q.Tag == 0)
    {
        return false;
    }
    n = Q.data[Q.front];
    return true;
}
int main()
{
    SqQueQue Q;
    InitSqQueque(Q);

    int n=0;
    int m=0;
    bool flag = QueIsEmpty(Q);
    if(flag)
    {
        printf("队列为空\n");
    }

    for (int i = 0; i < 7 ; ++i) {
        bool flag1 = EnQueQue(Q);
        if(!flag1)
        {
            printf("队列已满不能继续输入\n");
        }
    }
    getTopElem(Q,m);
    printf("此时队头为%d\n",m);
    DeQueQue(Q,n);
    printf("出队元素为%d\n",n);
    getTopElem(Q,m);
    printf("此时队头为%d",m);


}

以上都是队尾指针在队尾元素后一个空间，如果队尾指针指向队尾元素判断条件又不同 具体实现如下

//
// Created by Administrator on 2023/1/27.
//
//
// Created by Administrator on 2023/1/26.
//
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>


//初始化队列
/*
 * 步骤
 * 初始化队列  判断队列是否为空 入队 获取队头元素 出队
 */
#define MaxSize 5
typedef int ElemType;
typedef struct{
    ElemType data[MaxSize];
    ElemType front;
    ElemType rear;
}SqQueque;

//初始化队列
void InitQueque(SqQueque &Q)
{
    Q.front = 0;
    Q.rear = MaxSize-1;
}

//判断队列是否为空
bool QuequeEmpty(SqQueque Q)
{
    if((Q.rear+1)%MaxSize == Q.front )
    {
        return true;
    }
    return false;
}

//入队
bool EnQueque(SqQueque &Q)
{
    if((Q.rear+2) % MaxSize == Q.front) //入队先判断队列是否满，用尾指针来判断队列是否已经满了
    {
        return false;
    }
    int x;
    printf("请输入值\n");
    scanf("%d",&x);
    Q.rear = (Q.rear+1)%MaxSize;
    Q.data[Q.rear] = x;
    return true;
}

bool getTopElem(SqQueque Q, ElemType &n) {
    if ((Q.rear + 1) % MaxSize == Q.front) {
        return false;
    }
    n = Q.data[Q.front];
}

//出队
bool OutQueque(SqQueque &Q,ElemType &n)
{
    if((Q.rear+1) == Q.front) // 判断队列是否为空，当首指针与尾指针相等的时候 队列为空。
    {
        return false;
    }
    n = Q.data[Q.front];
    Q.front = (Q.front+1)%MaxSize;
    return true;
}

int main() {
    SqQueque Q;
    InitQueque(Q);

    int n=0;
    int m=0;
    bool flag = QuequeEmpty(Q);
    if(flag)
    {
        printf("队列为空\n");
    }

    for (int i = 0; i < 5 ; ++i) {
        bool flag1 = EnQueque(Q);
        if(!flag1)
        {
            printf("队列已满不能继续输入\n");
        }
    }
    getTopElem(Q,n);
    printf("队头元素为%d\n",n);
    OutQueque(Q,m);
    printf("出队元素为%d\n",m);
    getTopElem(Q,n);
    printf("队头元素为%d\n",n);



    return 0;

}

队尾指针指向队尾元素的第二种方式 与上面方法的区别只是在入队时需要注意顺序

//
// Created by JustinLiang on 2023/4/1.
//
#include <stdio.h>
#include <cstdlib>

typedef int Elemtype;
#define Maxsize 6
//顺序存储队列
typedef struct {
    Elemtype data[Maxsize];
    Elemtype rear;
    Elemtype front;
    int size;
}SqQueQue;


//初始化队列
void InitSqQueque(SqQueQue &Q)
{
    Q.front = 0;
    Q.rear = Maxsize-1;
    Q.size = 0;
}

//循环队列的判空
bool QueIsEmpty(SqQueQue Q)
{
    if(Q.size == 0)
    {
        return true;
    }
    return false;
}

//入队
bool EnQueQue(SqQueQue &Q)
{
    //判满
    if(Q.size == Maxsize)
    {
        return false;
    }
    int x;
    printf("请输入入队的值\n");
    scanf("%d",&x);
    Q.rear = (Q.rear +1) %Maxsize;
    Q.data[Q.rear] = x;
    Q.size++;
    return true;
}

//出队
bool DeQueQue(SqQueQue &Q,Elemtype &n)
{
    //判空
    bool flag = QueIsEmpty(Q);
    if(!flag)
    {
        n = Q.data[Q.front];
        Q.front = (Q.front+1) % Maxsize;
        Q.size--;
        return true;
    }
    return false;
}

//获取队头元素
bool getTopElem(SqQueQue Q, Elemtype &n)
{
    if(Q.size == 0)
    {
        return false;
    }
    n = Q.data[Q.front];
    return true;
}
int main()
{
    SqQueQue Q;
    InitSqQueque(Q);

    int n=0;
    int m=0;
    bool flag = QueIsEmpty(Q);
    if(flag)
    {
        printf("队列为空\n");
    }

    for (int i = 0; i < 7 ; ++i) {
        bool flag1 = EnQueQue(Q);
        if(!flag1)
        {
            printf("队列已满不能继续输入\n");
        }
    }
    getTopElem(Q,m);
    printf("此时队头为%d\n",m);
    DeQueQue(Q,n);
    printf("出队元素为%d\n",n);
    getTopElem(Q,m);
    printf("此时队头为%d",m);


}

循环队列  顺序存储表示

//
// Created by Administrator on 2023/1/27.
//
#include <stdio.h>

//循环队列  抽象数据结构为 数组和头指针尾指针
#define MaxSize 5
typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];
    ElemType front;//头指针
    ElemType rear;//尾指针
}SqQueque1;
// 用循环队列解决上溢问题
//初始化循环队列 判断队列是否为空 入队 获取队首元素 出队
void  InitQueque1(SqQueque1 &Q)
{
    Q.rear = 0;
    Q.front = 0;
}

bool  QuequeEmpty1(SqQueque1 *Q)
{
    if(Q->front ==Q->rear)
    {
        return true;
    }
    return false;
}

bool EnQueque1(SqQueque1 &Q, ElemType n)
{
    //先判断队列满了没有
    if( (Q.rear+1)%MaxSize == Q.front ) //因为要区别于空队列的判断条件，也就是说当尾指针指向最后一个空的空间时不可以放元素，这个时候尾指针已经处于循环队列的队尾了，队列已经是满队列了
    {
        return false;
    }
    Q.data[Q.rear] = n;
    Q.rear = (Q.rear+1)%MaxSize; // 移动队尾指针
    return true;
}

   //计算循环队列长du
ElemType QuequeLength(SqQueque1 Q)
   {
       return  ((Q.rear-Q.front)+MaxSize)%MaxSize;
   }
ElemType getFrontElem1(SqQueque1 Q)
{
    return Q.data[Q.front];
}
bool OutQueque1(SqQueque1 &Q,ElemType &n)
{
    //先判断队列是否为空，为空的话不能出队
    if(Q.front == Q.rear)
    {
        return false;
    }
    n = Q.data[Q.front]; //先进先出
    Q.front = (Q.front+1)%MaxSize;//移动队首指针

    return true;
}
int main3()
{
    SqQueque1 Q;
    int m;
    int a =0  ;
    InitQueque1(Q);
    bool flag = QuequeEmpty1(&Q);
    if(flag)
    {
        printf("循环队列为空\n");
    }

    EnQueque1(Q,1);
    EnQueque1(Q,2);
    EnQueque1(Q,3);
    EnQueque1(Q,4);
    a = QuequeLength(Q);
    printf("长度为%d\n",a);
    flag = EnQueque1(Q,5);//循环队列已满 不能插入返回False
    if(!flag)
    {
        printf("队列已满，无法插入元素\n");
    }
    a = getFrontElem1(Q);
    printf("此时循环队列首元素为%d\n",a);
    OutQueque1(Q,m);
    printf("循环队列出队元素为%d\n",m);
    a = getFrontElem1(Q);
    printf("此时循环队列首元素为%d\n",a);
    flag = EnQueque1(Q,5);
    if(flag)
    {
        printf("插入元素成功\n");
    }


    return  0;
}

 如果是在不清楚队列多长的情况下需要用到链式存储，也就是链队 。

//
// Created by Administrator on 2023/1/27.
//
#include <cstdlib>
#include "stdio.h"

//链队的结构体定义
typedef int ElemType;
typedef struct Linknode{
    ElemType data;
    struct Linknode *next;
}LinkNode;
typedef struct {
    LinkNode *front;
    LinkNode *rear;
}LinkQueque;
//初始化链队 入队 出队
//初始化链队
void  InitQueque2(LinkQueque &Q)
{
   Q.rear = Q.front =(LinkNode*)malloc(sizeof(LinkNode));
}
//判断是否为空
bool IsEmpty(LinkQueque Q)
{
    if(Q.front == Q.rear)
    {
        return true;
    }
    return false;
}
//入队 使用尾插法
void EnQueque2(LinkQueque &Q,ElemType n)
{
    LinkNode *s = (LinkNode*) malloc(sizeof (LinkNode));
    s->data = n;
    s->next = NULL;
    Q.rear->next = s;//利用尾部指针实现尾插法
    Q.rear = s;
}

//出队  头删法
bool DeQueque(LinkQueque &Q,ElemType &n)
{
   if(Q.front == NULL)//先要判断队列是否为空
   {
       return false;
   }
   LinkNode *p = Q.front->next;
   n = p->data;
   Q.front->next = p->next;
   if(p == Q.rear)//特殊情况 如果是最后一个结点的话需要回收尾指针。
   {
       Q.rear = Q.front;
   }
    free(p);
    return true;
}

int main()
{
    LinkQueque Q;
    int n ;
    InitQueque2(Q);
    bool flag = IsEmpty(Q);
    if(flag)
    {
        printf("链队为空\n");
    }
    EnQueque2(Q,1);
    EnQueque2(Q,2);
    EnQueque2(Q,3);
    DeQueque(Q,n);
    printf("被删除元素值为%d\n",n);

    return 0;
}

不带头节点的操作

//
// Created by JustinLiang on 2023/4/8.
//
#include <stdio.h>
#include <cstdlib>

typedef int Elemtype;


typedef int ElemType;
typedef struct Linknode{
    ElemType data;
    struct Linknode *next;
}LinkNode;
typedef struct {
    LinkNode *front;
    LinkNode *rear;
}LinkQueque;


//初始化链队   不带头节点
void InitLinkQueQue(LinkQueque &Q)
{
   Q.rear = NULL;
   Q.front = NULL;
}

//判空
bool IsQueQueEmpty(LinkQueque Q)
{
    return (Q.front==NULL) ;
}

//入队
void InsertNode(LinkQueque &Q)
{
    LinkNode *p = (LinkNode*) malloc(sizeof (LinkNode));
    int x;
    printf("输入入队的值\n");
    scanf("%d",&x);
    p->data = x;
    p->next = NULL;
    if(Q.front == NULL)
    {
        Q.front = p;
        Q.rear = p;
    } else{
        Q.rear->next = p;
        Q.rear = p;
    }
}

//出队
bool DeQueQue(LinkQueque &Q)
{
    bool flag =IsQueQueEmpty(Q);
    if(flag)
    {
        return false;
    }
    LinkNode *p =Q.front;
    if(Q.front == Q.rear)
    {
        Q.front = NULL;
        Q.rear = NULL;
        free(p);
    } else{
        Q.front = p->next;
        free(p);
    }
    return true;
}

//遍历链表
void PrintLink(LinkQueque Q)
{
    LinkNode *p = Q.front;
    while (p != NULL)
    {
        printf("%3d",p->data);
        p = p->next;
    }
}


int main()
{
  LinkQueque Q;
    InitLinkQueQue(Q);
    bool  flag = IsQueQueEmpty(Q);
    if(flag)
    {
        printf("链表为空");
    }
    flag = DeQueQue(Q);
    if(!flag)
    {
        printf("链表为空无法删除");
    }
    for (int i = 0; i < 5; ++i) {
        InsertNode(Q);
    }
    PrintLink(Q);
    printf("\n");
    for (int i = 0; i < 3; ++i) {
        DeQueQue(Q);
    }
    PrintLink(Q);
}

m0_57068311
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构实验报告2-栈与队列-队列基本操作算法-实验内容及要求.docx
07-06
编写程序，建立容量为n(建议n=8)的循环队列，完成以下程序功能。输入字符#，执行一次出队操作，屏幕上显示出队字符；输入字符@，队列中所有字符依次出队并按出队次序在屏幕上显示各字符；输入其它字符，则输入的字符...
数据结构栈与队列的总结（基于C语言）
博客记录学习轨迹，方便日后复习
04-12 1509
目录一、栈的概念和结构二、栈的实现1.栈的结构设置2.栈的初始化总结 一、栈的概念和结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。 栈中的数据遵从后进先出（Last In First Out）的原则。 压栈：栈的插入操作叫做压栈，入栈数据在栈顶。 出栈：栈的删除叫做出栈，出栈数据同样也在栈顶。 空栈：栈中没有元素，即栈为空。 二、栈的实现 由于栈的先入后出的特性，每一次入栈要从栈顶插入数据，即尾插。而每一次删除数据同样是从栈顶
栈的实现及总结
最新发布
weixin_52419751的博客
11-04 56
栈是一种特殊的线性表，它只允许从固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵循后进先出LIFO（Last In First Out）的原则。栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优游戏额。因为数组在尾插尾删数据时的代价比较小。分为三个文件实现，头文件，函数实现文件和测试文件。压栈：栈的插入操作叫做进栈/压栈/入栈，出栈：栈的删除操作叫做出栈，
数据结构与算法——队列
qq_38670588的博客
10-19 290
目录什么是队列队列的实现基于数组的队列实现基于链表的队列实现循环链表阻塞队列和并发队列问题 什么是队列 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。先进者先出，这就是典型的“队列”。 队列的实现 基于数组的队列实现 跟栈一样，队列可以用数组来实现，也可以用链表来实现。用数组实现的栈叫作顺序栈，用链表实现的栈叫作链式栈。同样，用数组实现的队列
JAVA中队列Queue和栈Stack的理解
Java后端技术栈
03-25 6704
什么是队列？ 队列是一种特殊的线性表，遵循先入先出、后入后出的基本原则，一般来说，它只允许在表的前端进行删除操作，而在表的后端进行插入操作，但是java的某些队列运行在任何地方插入删除；比如我们常用的 LinkedList 集合，它实现了Queue 接口，因此，我们可以理解为LinkedList 就是一个队列； java队列特性 队列主要分为阻塞和非阻塞，有界和无界、单向链表和双向链表之分； 阻塞和非阻塞 阻塞队列 入列(删除元素............
栈和队列学习总结
热门推荐
Marmara
04-04 1万+
一、栈 1、特点及应用 先进后出。（如果会和队列先进先出记混的话，就记场景吧：弹栈弹栈，就是把最上面的最新进来的弹出去；而队列就像我们火车站排队检票出站一样，谁排在前面谁就先出去。） 应用的话，其实我们经常接触呀。比如Undo操作（就是撤销操作）就是使用的栈的思想，以及程序调用的系统栈。下面我们举一个经典的括号匹配的例子： 题目要求： 给定一个只包括...
JavaScript数据结构学习之数组、栈与队列
10-19
主要给大家介绍了JavaScript数据结构之数组、栈与队列的相关资料，文中对数组、栈与队列的使用方法进行了详细的总结，相信对大家具有一定的参考学习价值，需要的朋友们下面来一起看看吧。
数据结构实验报告二(栈、队列与杨辉三角).docx
10-10
数据结构实验报告二(栈、队列与杨辉三角).docx
C++用两个栈实现一个队列（面试官的小结）
08-26
主要给大家介绍了关于C++用两个栈实现一个队列的相关资料，这是来自一名面试官的小结，文中通过示例代码介绍的非常详细，对大家学习或者使用C++具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
数据结构–队列（Java实现）
01-21
文章所涉及的资料来自互联网整理和个人总结，意在于个人学习和经验汇总，如有什么地方侵权，请联系本人删除，谢谢！ 简介 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的...
栈实验报告
03-31
1.了解栈和队列的特性。 2. 掌握栈的顺序表示和实现。 3. 掌握栈的链式表示和实现。 4. 掌握队列的顺序表示和实现。 5. 掌握队列的链式表示和实现。 6. 掌握栈和队列在实际问题中的应用。
栈与队列的学习总结
奔跑的蜗牛
05-07 5470
栈与队列1、栈1.1栈的定义1.2栈的存储结构及实现1.2.1栈的顺序存储1.2.2栈的链式存储1.3两栈共享存储空间1.4 栈的应用（四则运算表达式求值）2、队列2.1 队列的定义2.2循环队列2.3队列的链式存储结构及实现3、栈与队列的比较 1、栈 1.1栈的定义 栈是限定仅在表尾进行插入和删除操作的线性表 1.2栈的存储结构及实现 1.2.1栈的顺序存储 1.2.2栈的链式存储 1.3两栈共...
数据结构———栈和队列(万字超详细总结，建议收藏)
yydsssy的博客
09-24 2332
（即一个端点允许插入和删除，另一个端点只允许插入的双端队列）和输入受限的双端队列（即一个端点允许插入和删除，另一个端点只允许删除的双端队列）。如果开辟空间失败的话，直接退出，如果成功的话，则将值存入节点，接下来我们还需要判断是否是第一次插入，因为我们没有设置头节点，如果是首次插入，则tail为空，那么head和tail都是指向这第一个节点的否则只需要改变tail即可。队列的链式结构就是一个链表，但是他只能从尾部插入数据，从头部出数据，为了方便得知队列的有效元素个数，我们可以用一个整形size来记录。
【无标题】
kobe5152的博客
02-22 134
用队列实现栈和用栈实现队列 用队列实现栈 typedef int QDataType; typedef struct QListNode { struct QListNode* next; QDataType data; }QNode; // 队列的结构 typedef struct Queue { QNode* front; QNode* rear; }Queue; void QueueInit(Queue* q) { assert(q); q->front = NULL; q-&
栈与队列总结
Powerstot的博客
05-21 242
基础知识 Java中的栈一般用 Deque 实现，因为stack有设计上的缺陷，官方建议使用 Deque Deque的全称为：double ended queue（双端队列）： Deque 有三种用途 普通队列 双端队列 堆栈 一般实现Deque使用 ArrayDeque 或者 LinkedList ，根据增删多还是查询多来决定使用那个实现， 如果是增删多，使用 LinkedList 更加高效，如果是查询多，使用ArrayDeque 更高效 双端队列两端访问元素的方法，提供插入，删除和检查元素方法
数据结构学习总结（四）队列和栈
csdnligao的博客
07-18 1919
3.队列 队列其实可以看作是一种特别的线性表，一种对存储有特定要求的线性表。队列的特性就是FIFO——先进先出，就像平常的排队一样，先排队的先处理，队列中的进、出一般用PUSH、POP表示。队列是一种使用频率非常高的数据结构，在很多算法中（如图的广度优先遍历等）队列是实现的关键。 由于队列是一种特殊的线性表，因而队列的实现是基于线性表的实现的，只不过在对线性表的操作上，要特殊化，使其符合队列的
数据结构-栈和队列小结
明亮的技术博客
10-24 7812
1栈   1>栈的定义：       栈是限定仅在表尾进行插入和删除操作的线性表。       我们把插入和删除的一端称为栈顶（TOP），另一端称为栈底（BOTTOM）,不包含任何元素的栈称为空栈。栈又称为后进先出（Last in first out）的线性表，简称LIFO结构。    2>栈的存储结构     由于栈也是线性表，因此线性表的存储结构对栈也使用，通常有顺序栈和链栈两种存储
数据结构之栈与队列学习总结
小帅的专栏
01-23 4303
栈与队列更多的作为程序员的工具来使用，构思算法的辅助工具，而数组、链表等是作为数据存储工具，适用于数据库应用中做数据记录，但栈与队列不是完全的数据存储工具，他们的生命周期比较短，在程序操作执行期间他们才被创建，在完成任务后就被销毁。栈与队列的访问是受限制的，即在特定时刻只有一个数据项可以被读取或被删除。他们可以用数组或链表来实现，比数组、链表更加抽象。Stack在解析算数表达式方面
《大话数据结构》----第四章---栈与队列 （学习小结）
博客 小站
07-24 327
一、栈和队列是啥 ？？ 栈是限定仅在表尾进行插入和删除操作的线性表。 队列是只允许在一端进行插入操作、而在另一端进行删除操作的线性表。 二、解释下栈的特点？ 2.1 如何理解栈？     我们把允许插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom)，不含任何数据元素的栈称为空栈。栈又称为后进先出(Lasf In First Out)的线性表，简称LIFO结构。     ...
数据结构栈和队列实验小结
05-12
在数据结构课程中，栈和队列是两个非常重要的数据结构。他们的实现方式有很多，比如数组实现、链表实现等等。在实验过程中，我们通过实现栈和队列来深入理解他们的实现原理和应用场景。 在栈的实验中，我们学习了栈...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值