数据结构编程笔记九：第三章 栈和队列 链队列的实现

最新推荐文章于 2022-08-11 17:06:56 发布
最新推荐文章于 2022-08-11 17:06:56 发布
阅读量534 收藏 3
点赞数
分类专栏： 学习笔记 文章标签： 编程 数据结构 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014576141/article/details/77418397
版权

上次我们一起看了顺序栈的实现，并且完成了一个书上的小应用——进位制程序。

今天我们一起看看另一种特殊的线性表——队列的链式存储结构实现。
还是老规矩：

程序在码云上可以下载。
地址：https://git.oschina.net/601345138/DataStructureCLanguage.git

队列也是一种被限制插入和删除位置的线性表。与栈不同的是，它限制插入只能发生在线性表尾部，删除只能发生在线性表头部，不能从除了队头和队尾的中间任意位置执行插入删除操作。这就造成了队列一头进另一头出的特征——“先进先出，后进后出”（LILO，FIFO）。

还要向大家强调一点：栈和队列是非常重要的两种数据结构，我们在后期的程序中会经常把栈和队列引入，作为一种工具来使用。而且在操作系统中也会有大量知识点涉及到队列，所以希望大家务必对它重视起来，动手敲代码！

先看看队列的抽象数据类型ADT描述：

ADT Queue {
 数据对象：D= {ai|ai∈ Elemset,(i=1,2,…,n, n≥0)}
 数据关系：R1 = {＜ai-1, ai＞|ai-1,ai∈ D,(i=2,3,…,n)}   约定a1为队头, an为队尾, 且第一个结点的数据域用于存放元素个数。
基本操作：
   1. InitQueue(&Q)
      操作结果:构造一个空的队列Q。
   2. DestroyQueue(&Q)
      初始条件: 队列Q已经存在。
      操作结果: 销毁队列Q。 
   3. ClearQueue (&Q)
      初始条件: 队列Q已经存在。
      操作结果: 将队列Q清为空队列。
   4. QueueEmpty(Q)
      初始条件: 队列Q已经存在。
      操作结果:若Q为空队列，则返回TURE;否则返回FALSE。
   5. QueueLength(Q)
      初始条件:队列Q已经存在。
      操作结果:返回Q中的数据元素个数，即队列长度。
   6. GetHead(Q,&e)
      初始条件:队列Q已经存在且非空。
      操作结果:用e返回队列Q中的队头元素。
   7. EnQueue(&Q,e)        // 入队操作
      初始条件:队列Q已经存在。
      操作结果:插入元素e为新的队尾元素。
   8. DeQueue(&Q,&e)      // 出队操作
      初始条件:队列Q已经存在且非空。
      操作结果:删除Q的队头元素，并用e返回其值。
   9. QueueTraverse(Q,visit())
      初始条件:队列Q已经存在且非空。
      操作结果:从队头到队尾依次对Q的每个元素调用函数visit ()。一旦visit ()失败，则操作失败。

接下来看看队列的链式存储结构的实现：

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>引入头文件<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

#include <stdio.h>   //使用了标准库函数 printf(),scanf()
#include <stdlib.h>  //使用了动态内存分配函数 malloc(),free()

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>自定义符号常量<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< 

#define OVERFLOW -2         //内存溢出错误常量
#define OK 1                //表示操作正确的常量 
#define ERROR 0             //表示操作错误的常量
#define TRUE 1              //表示逻辑为真的常量 
#define FALSE 0             //表示逻辑为假的常量

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>自定义数据类型<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

typedef int Status;       //用typedef给int起个别名，也便于程序的维护 
typedef float QElemType;    //用typedef给float起个别名，也便于程序的维护

typedef struct  QNode{  //链队列的C语言表示                  
     QElemType data;        //数据域 
     struct QNode * next;   //指针域 
}QNode,* QueuePtr;

typedef struct{
    QueuePtr front;  //队头指针 
    QueuePtr rear;   //队尾指针 
}LinkQueue; 

//---------------------------------链队列的主要操作----------------------------------

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>1.初始化链队列<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

/*
    函数：MallocQNode
    参数：无 
    返回值：指向新申请结点的指针 
    作用：为链队列结点申请内存的函数 
*/
QueuePtr MallocQNode(){

    //工作指针p，指向新申请的结点 
    QueuePtr p;

    //if(!(p = (QueuePtr)malloc(sizeof(QNode))))  相当于以下两行代码： 
    //p = (QueuePtr)malloc(sizeof(QNode));
    //if(!p)  <=>  if(p != NULL) 
    //申请结点的内存空间，若失败则提示并退出程序
    if(!(p = (QueuePtr)malloc(sizeof(QNode)))){
        printf("内存分配失败，程序即将退出！\n");
        exit(OVERFLOW);
    }//if

    //返回新申请结点的地址 
    return p;
}//MallocQNode

/*
    函数：InputQueueElem
    参数：LinkQueue &Q 链队列引用 
    返回值：状态码，操作成功返回OK 
    作用：为链队列Q输入n个元素
*/
Status InputQueueElem(LinkQueue &Q){

    //工作指针p
    QueuePtr p, q;

    //接收从键盘上输入的新的队列结点元素 
    QElemType e; 

    //n是队列将要存储元素的个数，也就是队列的长度
    //i是个临时变量，供循环使用 
    int n, i;

    //先确定队列中要初始化多少个元素n 
    printf("您想为链队列输入几个元素   ");
    scanf("%d", &n);

    //为队列初始化每一个元素 
    printf("请依次输入所有元素，用空格隔开:\n");
    for(i = 0; i < n; i++){

        //step1:申请新结点内存空间并使p指向此结点 
        p = MallocQNode();
        scanf("%f", &e);

        //step2:从键盘接收元素值并存入新结点的数据域 
        p->data = e;

        //step3:将新结点添加到队尾 
        Q.rear->next = p;

        //step4:修正尾指针的位置，使尾指针指向p指向的新添加的结点 
        Q.rear = p;
    }//for

    //step5:新插入的结点后面没有结点，所以将其设为NULL
    Q.rear->next = NULL;

    //step6:将计数器修改为初始化元素的个数 
    Q.front->data = n;

    //操作成功 
    return OK;
}//InputQueueElem 

/*
    函数：InitQueue
    参数：LinkQueue &Q 链队列引用 
    返回值：状态码，操作成功返回OK 
    作用：构建一个空队列 Q
*/
Status InitQueue(LinkQueue &Q) {

    //申请头结点的内存空间，并使队头和队尾指针同时指向它
    Q.front = Q.rear = MallocQNode();

    //由于头结点刚刚初始化，后面还没有元素结点 
    Q.front->next = NULL;

    //头结点数据域记录了链队列长度
    //由于此时链队列没有数据节点，所以将头结点数据域设为0 
    Q.front->data = 0;

    //从键盘输入队列元素初始化队列 
    InputQueueElem(Q);

    //操作成功 
    printf("链队列已成功创建！\n");
    return OK;
}//InitQueue 

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>2.销毁链队列<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

/*
    函数：DestoryQueue
    参数：LinkQueue &Q 链队列引用 
    返回值：状态码，操作成功返回OK 
    作用：销毁队列Q
*/
Status DestoryQueue(LinkQueue &Q){

    //从头结点开始向后逐个释放结点内存空间 
    while(Q.front){ //while(Q.front) <=> while(Q.front != NULL)

        //队尾指针指向被删除结点的后继结点 
        Q.rear = Q.front->next;

        //释放Q.front指向的被删除结点的空间 
        free(Q.front);

        //队头指针后移，指向下一个待删除结点 
        Q.front = Q.rear; 
    }//while

    //操作成功 
    printf("链队列已成功销毁！\n");
    return OK;
}//DestoryQueue

//>>>>>>>>>>>>>>>>>>>>>>>>>>>3.判断链队列是否为空<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

/*
    函数：QueueEmpty
    参数：LinkQueue Q 链队列Q 
    返回值：状态码，若Q为空队列，则返回TRUE;否则返回FALSE
    作用：判断队列Q是否为空 
*/
Status QueueEmpty(LinkQueue Q){

    //队头指针和队尾指针均指向链队列头结点表示链队列为空 
    if(Q.rear == Q.front){
        printf("该队列是空队列！\n");
        return TRUE; 
    }//if
    else {
        return FALSE; 
    }//else
}//QueueEmpty

//>>>>>>>>>>>>>>>>>>>>>>>>>>4.获取链队列的长度<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

/*
    函数：QueueLength
    参数：LinkQueue Q 链队列Q 
    返回值：队列Q中的数据元素个数，即队列长度
    作用：获取队列Q长度 
*/
int QueueLength(LinkQueue Q) {   

    //队列长度保存在链队列头结点的数据域中 
    return Q.front->data; 
}//QueueLength

//>>>>>>>>>>>>>>>>>>>>5.在链队列中插入元素（入队）<<<<<<<<<<<<<<<<<<<<<<<<

/*
    函数：EnQueue
    参数：LinkQueue &Q 链队列Q的引用
          QElemType e  被插入的元素e 
    返回值：状态码，操作成功后返回OK。 
    作用：插入元素e为Q的新的队尾元素
*/
Status EnQueue(LinkQueue &Q, QElemType e){

    //申请一个新的结点，并使p指向这个新结点 
    QueuePtr p = MallocQNode(); 

    //将待插入元素e保存到新结点数据域 
    p->data = e;

    //由于新结点要插在队尾，后面没有其他结点，所以后继指针域的值为NULL 
    p->next = NULL;

    //将新结点链入到队尾 
    //队列要求插入操作只能发生在队尾 
    Q.rear->next = p;

    //修正队尾指针，使之指向p所指向的新插入的结点 
    Q.rear = p;

    //由于插入一个结点，所以存储在头结点中的队列长度+1 
    Q.front->data++;

    //插入操作成功 
    return OK; 
}//EnQueue 

//>>>>>>>>>>>>>>>>>>>>>>>6.在链队列中删除元素（出队）<<<<<<<<<<<<<<<<<<<<<<<<<<

/*
    函数：DeQueue
    参数：LinkQueue &Q 链队列Q的引用
          QElemType &e 带回被删除结点的元素e 
    返回值：状态码，操作成功后返回OK。 
    作用：若队列不空,则删除Q的队头元素,用e返回其值
*/
Status DeQueue(LinkQueue &Q, QElemType &e){

    //注意队列为空和队列不存在的区别，队列为空，头结点一定存在，
    //队列不存在时头结点一定不存在
    //对空队列执行出队操作没有意义，出队操作执行前要先检查队列是否为空 
    if(QueueEmpty(Q)) { //if(QueueEmpty(Q)) <=> if(QueueEmpty(Q) != TRUE)
        return ERROR;
    }//if

    //工作指针p指向队头第一个结点（不是头结点，是头结点的后继）
    //队列要求删除操作只能发生在队头，所以p指向的就是待删除节点 
    QueuePtr p = Q.front->next;

    //保存被删除结点的值 
    e = p->data;

    //在删除操作执行前修正队头指针的位置，使之在删除结点后指向新的队头结点 
    Q.front->next = p->next;

    //若被删除结点恰好是队尾结点，那么该结点被删除后，队列将会变成空队列
    //此时刚好满足空队列条件：Q.rear == Q.front，所以要修正队尾指针的位置，使之指向头结点 
    if(Q.rear == p) { 
        Q.rear = Q.front;
    }//if

    //在队头指针和队尾指针的位置都调整好了之后就可以
    //放心地释放p指向的结点的内存空间了 
    free(p);

    //由于从队列中删除了一个结点，头结点存储的队列长度应当-1 
    Q.front->data--;

    //操作成功 
    return OK; 
}//DeQueue

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>7.置空链队列<<<<<<<<<<<<<<<<<<<<<<<<<<<<

/*
    函数：ClearQueue
    参数：LinkQueue &Q 链队列Q的引用
    返回值：状态码，操作成功后返回OK。 
    作用：若队列不空,则清空Q
*/
Status ClearQueue(LinkQueue &Q){

    //清空、删除（出队）和销毁的区别和联系：
    //联系：三者都存在释放内存空间的操作，且清空和销毁操作会导致
    //      队列中所有存储数据的结点内存空间均被释放 
    //区别：清空操作只释放数据结点的内存空间，不影响头结点。
    //      但是销毁操作会在释放数据结点空间时一并释放掉头结点的内存空间。
    //      删除操作只能删除头结点外的数据结点，并且一次只可以删除一个结点。
    //      另外，只有删除操作可以带回被删除元素的值，另外两种操作不能。 

    //对空队列进行清空操作没有意义，所以要先判断队列是否为空 
    //注意队列为空和队列不存在的区别，队列为空，头结点一定存在，
    //队列不存在时头结点一定不存在 
    if(QueueEmpty(Q)) { //if(QueueEmpty(Q)) <=> if(QueueEmpty(Q) != TRUE)
        return ERROR;
    }//if

    //工作指针p指向队头结点（不是头结点），q是临时变量 
    QueuePtr p = Q.front->next, q;

    //从队头依次删除每个结点 
    while(p){ //while(p)  <=>  while(p != NULL)

        //使得q指向p指向结点的后继结点 
        q = p->next;

        //释放掉p指向结点的空间 
        free(p);

        //p向后移动，指向被删除结点的后继结点，该结点成为新的删除目标 
        p = q; 
    }//while

    //队列清空后头结点后面没有结点 
    Q.front->next = NULL; 

    //此时队列为空队列，所以队头指针和队尾指针都指向头结点 
    Q.rear = Q.front;

    //由于队列中的数据节点被清空，所以头结点存储的队列长度清零 
    Q.front->data = 0;

    //队列清空操作成功  
    printf("链队列已清空，长度为：%d\n",QueueLength(Q));
    return OK; 
}//ClearQueue 

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>8.遍历整个链队列<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

/*
    函数：Print
    参数：ElemType e 被访问的元素 
    返回值：状态码，操作成功返回OK，操作失败返回ERROR 
    作用：访问元素e的函数，通过修改该函数可以修改元素访问方式，
          该函数使用时需要配合遍历函数一起使用。 
*/
Status Print(QElemType e){

    //指定元素的访问方式是控制台打印输出 
    printf("%6.2f    ",e);

    //操作成功 
    return OK;
}//Print

/*
    函数：QueueTraverse
    参数：LinkQueue Q 链队列Q 
          Status (* visit)(QElemType) 函数指针，指向元素访问函数。 
    返回值：状态码，操作成功返回OK，操作失败返回ERROR 
    作用：调用元素访问函数按出队顺序完成链队列的遍历，但并未真正执行出队操作 
*/
Status QueueTraverse(LinkQueue Q, Status (* visit)(QElemType)) {   

    //对空队列进行遍历操作没有意义，所以遍历操作前要先判断队列是否为空 
    //注意队列为空和队列不存在的区别，队列为空，头结点一定存在，
    //队列不存在时头结点一定不存在  
    if(QueueEmpty(Q)) { //if(QueueEmpty(Q)) <=> if(QueueEmpty(Q) != TRUE)
        return ERROR;
    }//if

    //工作指针p指向队头结点 
    QueuePtr p = Q.front->next;

    //从队头结点开始依次访问每个结点，直到队尾 
    while(p) { //while(p)  <=>  while(p != NULL) 

        //调用元素访问函数 
        if(!visit(p->data)) { 
            printf("输出发生错误！\n");
            return ERROR;
        }//if

        //工作指针p后移，指向下一个元素 
        p = p->next;
    }//while

    //输出换行，使结果清楚美观 
    printf("\n");

    //操作成功 
    return OK; 
}//QueueTraverse

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>9.获取队头元素的值<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

/*
    函数：GetHead
    参数：LinkQueue Q 链队列Q 
          QElemType &e 带回队头元素的值 
    返回值：状态码，操作成功返回OK，操作失败返回ERROR 
    作用：获取队列Q的队头结点元素值，并用e返回该值，此操作不会导致出队操作 
*/
Status GetHead(LinkQueue Q, QElemType &e){

    //对空队列进行获取队头操作没有意义，所以操作前要先判断队列是否为空 
    //注意队列为空和队列不存在的区别，队列为空，头结点一定存在，
    //队列不存在时头结点一定不存在  
    if(QueueEmpty(Q)) { //if(QueueEmpty(Q)) <=> if(QueueEmpty(Q) != TRUE)
        return ERROR;
    }//if

    //保存队头结点元素的值
    //Q.front->next指示的是头结点后面的队头结点 
    e = Q.front->next->data;

    //操作成功 
    return OK; 
}//GetHead

//------------------------------主函数------------------------------------------- 
int main(int argc,char *argv[]){

    LinkQueue Q; 
    QElemType e;
    int tmp, tmp1 = 0, i, n;
    while(1){
        printf("\n***************************链队列完整引用版测试程序****************************\n");
        printf("->1.初始化链队列Q\n");
        printf("->2.清空链队列Q\n");
        printf("->3.输出链队列Q的所有元素（遍历）\n");
        printf("->4.查看链队列的长度（元素个数）\n");
        printf("->5.获得队头元素的值\n");
        printf("->6.在链队列中插入一个元素（入队）\n");
        printf("->7.在链队列中删除一个元素（出队）\n");
        printf("->8.销毁链队列Q\n");
        printf("->9.退出程序\n"); 
        while(1){
            printf("请输入您想要操作的代号：");
            scanf("%d", &tmp);
            switch(tmp){
                case 1:{
                     if(tmp1){ //if(tmp1) <=> if(tmp1 != 0)
                        printf("链队列Q已存在，且含有元素，队列销毁中...\n");
                        DestoryQueue(Q); 
                     }//if 
                     printf("->初始化链队列Q\n"); 
                     InitQueue(Q);
                     printf("初始化后的链队列包含以下元素：\n");
                     QueueTraverse(Q, Print);
                     tmp1 = 1;
                     break;
                }//case-1
                case 2:{
                     if(!tmp1){ //if(!tmp1) <=> if(tmp1 == 0)
                        printf("链队列Q不存在，您可能还未创建，请在创建(执行操作1)后执行该操作！\n\n");
                        break;
                     }//if 
                     printf("->清空链队列Q\n");
                     ClearQueue(Q); 
                     break;
                }//case-2
                case 3:{
                     if(!tmp1){ //if(!tmp1) <=> if(tmp1 == 0)
                        printf("链队列Q不存在，您可能还未创建，请在创建(执行操作1)后执行该操作！\n\n");
                        break;
                     }//if
                     printf("->链队列Q的所有元素为：\n");
                     QueueTraverse(Q, Print);
                     break;
                }//case-3
                case 4:{
                     if(!tmp1){ //if(!tmp1) <=> if(tmp1 == 0)
                        printf("链队列Q不存在，您可能还未创建，请在创建(执行操作1)后执行该操作！\n\n");
                        break;
                     }//if
                     printf("链队列Q的长度为%d\n", QueueLength(Q));
                     break;
                }//case-4
                case 5:{ 
                     if(!tmp1){ //if(!tmp1) <=> if(tmp1 == 0)
                        printf("链队列Q不存在，您可能还未创建，请在创建(执行操作1)后执行该操作！\n\n");
                        break;
                     }//if
                     i = GetHead(Q, e);
                     if(i) { //if(i) <=> if(i != ERROR)
                        printf("队头元素的值为%6.2f\n", e);
                     }//if 
                     else {
                        printf("队列可能已被清空或被删光元素，此时不存在队头元素！\n");
                     }//else
                     break;
               }//case-5
               case 6:{
                     if(!tmp1){ //if(!tmp1) <=> if(tmp1 == 0)
                        printf("链队列Q不存在，您可能还未创建，请在创建(执行操作1)后执行该操作！\n\n");
                        break;
                     }//if
                     printf("->对Q执行入队操作\n");
                     printf("您想在队列中插入的元素是：");
                     scanf("%f", &e);
                     EnQueue(Q, e);
                     printf("元素入队后队列为\n");
                     QueueTraverse(Q, Print);
                     break;
               }//case-6
               case 7:{
                     if(!tmp1){ //if(!tmp1) <=> if(tmp1 == 0)
                        printf("链队列Q不存在，您可能还未创建，请在创建(执行操作1)后执行该操作！\n\n");
                        break;
                     }//if
                     printf("->对Q执行出队操作\n");
                     i = DeQueue(Q, e);
                     if(i){ //if(i) <=> if(i != ERROR)
                        printf("出队的元素是%6.2f \n", e);
                        printf("元素出队后队列为\n");
                        QueueTraverse(Q, Print);
                     }//if
                     else {
                        printf("队列可能已被清空或被删光元素，此时没有元素可以出队！\n");
                     }//else 
                     break;
               }//case-7
               case 8:{
                     if(!tmp1){ //if(!tmp1) <=> if(tmp1 == 0)
                        printf("链队列Q不存在，您可能还未创建，请在创建(执行操作1)后执行该操作！\n\n");
                        break;
                     }//if
                     printf("->销毁链队列Q\n"); 
                     DestoryQueue(Q); 
                     tmp1 = 0;
                     break;
               }//case-8
               case 9:{
                     printf("程序退出,再见！\n\n");
                     exit(0);
                     break;
               }//case-9
               default:{
                     printf("您的输入非法，请重新输入！\n\n");
                     break; 
               }//default
            }//switch 
            break;
        }//while
        system("PAUSE");
        system("cls");  
    }//while        
    return 0;
}//main

以下是程序运行时输入的测试数据和对应输出：

***************************链队列完整引用版测试程序****************************
->1.初始化链队列Q
->2.清空链队列Q
->3.输出链队列Q的所有元素（遍历）
->4.查看链队列的长度（元素个数）
->5.获得队头元素的值
->6.在链队列中插入一个元素（入队）
->7.在链队列中删除一个元素（出队）
->8.销毁链队列Q
->9.退出程序
请输入您想要操作的代号：1
->初始化链队列Q
您想为链队列输入几个元素   10
请依次输入所有元素，用空格隔开:
2 45 6 98 4 23 5 9 8 49
链队列已成功创建！
初始化后的链队列包含以下元素：
  2.00     45.00      6.00     98.00      4.00     23.00      5.00      9.00
  8.00     49.00
请按任意键继续. . .

请输入您想要操作的代号：3
->链队列Q的所有元素为：
  2.00     45.00      6.00     98.00      4.00     23.00      5.00      9.00
  8.00     49.00
请按任意键继续. . .

请输入您想要操作的代号：4
链队列Q的长度为10
请按任意键继续. . .

请输入您想要操作的代号：5
队头元素的值为  2.00
请按任意键继续. . .

请输入您想要操作的代号：6
->对Q执行入队操作
您想在队列中插入的元素是：69
元素入队后队列为
  2.00     45.00      6.00     98.00      4.00     23.00      5.00      9.00
  8.00     49.00     69.00
请按任意键继续. . .

请输入您想要操作的代号：7
->对Q执行出队操作
出队的元素是  2.00 
元素出队后队列为
 45.00      6.00     98.00      4.00     23.00      5.00      9.00      8.00
 49.00     69.00
请按任意键继续. . .

请输入您想要操作的代号：2
->清空链队列Q
链队列已清空，长度为：0
请按任意键继续. . .

请输入您想要操作的代号：3
->链队列Q的所有元素为：
该队列是空队列！
请按任意键继续. . .

请输入您想要操作的代号：4
链队列Q的长度为0
请按任意键继续. . .

请输入您想要操作的代号：8
->销毁链队列Q
链队列已成功销毁！
请按任意键继续. . .

请输入您想要操作的代号：9
程序退出,再见！


--------------------------------
Process exited with return value 0
Press any key to continue . . .

总结：
1.队列的各项操作要重点关注队头指针和队尾指针的位置。
2.删除操作不要忘记考虑极端情况：删除队头结点和删除队尾结点。
3.插入和删除操作发生后要及时修改队头和队尾指针，保证其指向的正确性。同时不要忘记修改存储在头结点中的队长。
4.链队列空的判断条件：Q.front == Q.rear 即队头和队尾指针均指向头结点。
5.删除操作一定要判断队列是否为空，但是由于我们使用了链式存储结构，并且没有对队列长度作出限制，所以不需要考虑插入操作判断队列是否为满的问题。

下次的文章，我们会介绍队列的顺序存储结构的实现——循环队列。希望大家继续关注我的博客，期待下次再见！

逗比驾到
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链栈和链队列的实现
11-19
链栈和链队列的实现，用二级指针实现出栈、入栈，展示了二级指针的用法
数据结构第三章笔记——栈和队列
10-21
数据结构第三章笔记——栈和队列
数据结构与算法：链式栈与链式队列的基本操作（带头节点与不带头节点对比分析）
weixin_50690285的博客
08-11 304
代码】数据结构与算法：链式栈与链式队列的基本操作（带头节点与不带头节点对比分析）
数据结构实验5_C语言_链队列的基本操作、入队、出队、获取队头元素等
xiaosi的博客
10-30 8363
实验5、链队列的基本操作 （1）实验目的 通过该实验，使学生理解链队列的构造特点并灵活应用，掌握链队基本操作的编程实现，认识栈是在一端进行插入，在另一端进行删除集中操作的线性结构，掌握队列的“先入先出”操作特点，知道判断队列空和满的条件，进一步熟悉C语言中指针操作。 （2）实验内容 用链式存储结构，实现教材定义的队列的基本操作。 （3）参考界面 菜单中包括以下功能： 初始化队列， 销毁队列， 清空队列， 队列判空， 求队列长度， 获取队头元素， 插入一个 元素， 删除一个元素， 输出所有元素。 要求：自
第九章数据结构
睡个好觉吗
12-06 630
算法设计与算法分析内涵、算法的时间复杂度和空间复杂度，能够结合具体算法分析时间复杂度和空间复杂度； 数据结构基础：数据结构内涵、线性表（特别是堆栈和队列）的理解、二叉树的遍历方法以及图的深度优先搜 索和广度优先搜索的理解 数据：是描述客观事物的数和字符的集合 ★数据结构：指所有数据元素以及数据元素之间的关系。数据结构=数据+结构 数据类型：是一组性质相同的值的集合和定义在此集合上的一组操作的总称。 抽象数据类型（ADT）：指的是用户进行软件系统设计时从问题的数据模型中抽象出来的逻辑数据结构和逻辑 数据结构上
数据结构--链式栈与链式队列设计与实现（c++描述）
m0_54759841的博客
03-16 1646
链式栈与链式队列的设计与实现（c++描述） 本文主要讨论的是链式栈与链式队列的设计思想与实现对于链表的基本知识此处不予过多讨论 链式栈 链栈结构描述 见下图 几点解释说明： 此处栈顶指针也即表头指针，因为此处选择的链表为单向链表，无法从当前结点得出其前驱结点，由于栈的操作均在一端进行因此将栈顶指针设在表头更便于进行出栈和入栈 此处我选择使用count主要是因为考虑到如果说要获取栈内元素个数时，通过count能节省再去遍历链表获得存储空间造成的时间浪费，属于以空间换时间。 由于是链式结构，存储空间是我们n
《数据结构及其应用》笔记含答案 第三章_栈和队列.docx
05-28
《数据结构及其应用》笔记含答案 第三章_栈和队列.docx《数据结构及其应用》笔记含答案 第三章_栈和队列.docx《数据结构及其应用》笔记含答案 第三章_栈和队列.docx《数据结构及其应用》笔记含答案 第三章_栈和队列....
数据结构笔记：双端队列
01-21
双端队列（deque，double-ended queue），是一种具有队列和栈的性质的数据结构。 双端队列中每一端，都可以进行存入和取出，去其中一段，都像一个栈一样。 存取也只限定在两端，不能在中间 双端队列的实现 通过...
栈和队列onenote笔记pdf
10-16
栈和队列是数据结构中两种基本的数据存储结构，它们都是线性表的实现方式，但它们之间有着明显的区别。 首先，栈是一种后进先出的数据结构，即最新添加的元素将被最先删除。栈可以想象成一个餐盘，叠加的餐盘中最新...
栈和队列基础算法
peerless1024的博客
03-29 451
以不带头结点的单链表存储栈，设计初始化栈、判断栈是否为空、进栈和出栈等相应的算法。 typedef struct LNode { //定义单链表结点结构 ElemType data; struct LNode * next; }LNode, *LinkStack;Status InitStack(LinkStack &L) { //初始化栈 L = NUL
数据结构-循环队列的基本操作函数实现（含全部代码）
关注网络安全、云原生安全
09-17 1万+
主要包含以下函数： InitQueue(SqQueue &Q) 参数：循环队列Q 功能：初始化循环队列Q 时间复杂度：O(1) QueueEmpty(SqQueue Q) 参数：循环队列Q 功能：判断队空与否 时间复杂度：O(1) EnQueue(SqQueue &Q,QElemType e)...
通过数据结构实现对队列的一般操作
weixin_45818002的博客
03-11 82
队列1. 静态循环队列2. 链式队列 1. 静态循环队列 代码： # include <stdio.h> # include <malloc.h> # include <stdlib.h> # include <stdbool.h> typedef struct Queue { int *pBase; int front; ...
链栈与链队列
xwl666666的博客
01-15 259
链栈与链队列 想想是该整理一下学长一钱不值的链栈与链队列的任务，，不知道自己这样写的有没有问题，符不符合原理，如果有什么问题，请大家能不吝赐教，帮忙斧正。 链栈 首先，我们先搞清楚，栈的原理就是现金后出，譬如往箱子里面放球，最先放进去的最后拿出来。下面给一下我臭臭的代码： #include<stdio.h> #include<stdlib.h> //定义结构体 struct...
队列的顺序存储（循环队列）和链式存储（带和不带头结点）C/C++实现
qq_49818809的博客
04-01 1655
队列的顺序存储（循环队列）和链式存储（带和不带头结点）C/C++实现 文章目录队列的顺序存储（循环队列）和链式存储（带和不带头结点）C/C++实现@[TOC](文章目录)一、循环队列1.引入库二、链式队列（带头结点）1.引入库2.读入数据三、链式队列（ 不带头结点）四、总结 由于队列的顺序存储中存在“假溢出”或“上溢出”，一般在使用中会采用循环队列或链式队列，下面给出循环队列和链式队列（带和不带头结点）的实现。 一、循环队列
链栈和队列基础知识
ccnnli的博客
03-24 1252
1、对于链栈来说，基本不存在栈满的情况，除非内存已经没有可以使用的空间了，如果真的发生，那此时计算机操作系统已经面临斯基崩溃，而不是这个链栈是否溢出的问题。 2、 （以上内容纯属本人大话数据结构概括整理，如有错误，欢迎批评指正）
链队列的简单操作（入队，出队，输出队元素等）
热门推荐
口中冰的博客
10-27 3万+
定义一个节点，里面包含元素类型，指向下一个节点的指针。然后定义一个结构体，里面两个指针，指向队头和队尾 typedef struct QNode { int data; struct QNode * next; }QNode, * Queue; typedef struct { Queue front; Queue rear; }LinkQueue; 入队操作要注意别...
数据结构——循环队列和链队——c语言代码实现
❀雾里看花花里看雾❀
07-11 504
嗨喽，csdn的小伙伴们，我又来啦~ 这一周因为生产实习，我可谓是被生活磨平了棱角呢！ 本来还想瘦个几斤对吧，结果跑步不想跑，跳绳不想跳，买了一个瑜伽垫觉得睡着比床还舒服，是我本人了哈哈哈哈哈，果然生产队的????都不敢这么歇！ 今天周日对吧，本来应该是休息的时间 生产实习之外的自我学习时间，我！！！我开始追综艺了！！！罪恶啊！！！但是但是但是《心动的信号》怎么可以这么甜哈哈哈哈哈，从第一季追到第四季，是我本人了！！！太罪恶了！！ 最近还在磕CP，《你微笑时很美》哈哈哈许凯和程潇，nice啊！！话说我怎么喜
手动实现 链式栈结构、链式队列
weixin_44579258的博客
05-20 145
** * 实现一个链式栈结构 * @param <T> */ class LinkStacked<T>{ /** * 链表的节点类型定义 * @param <T> */ static class Entry<T>{ T data; Entry<T> nex...
Java实现链栈和链队列
LiangCJP的博客
08-23 427
继上次更新，同样将以前C++的实现转换为Java实现。 先来看看链栈 import javax.print.attribute.Size2DSyntax; public class LinkStack&lt;E&gt; { private Node&lt;E&gt; top; //栈顶元素 private int size; class Node&lt;E&gt;{ E e;...
队列的初始化、入队列、出队列、判断队列是否为空、求队列长度和输出显示队列元素C++总代码
最新发布
11-08
队列是一种线性数据结构，它具有先进先出（FIFO）的特点。循环队列是一种特殊的队列，它可以充分利用数组空间，避免了普通队列的假溢出现象。下面是C++实现循环队列的基本操作的代码： ```c++ #include <iostream> using namespace std; #define MAXQSIZE 100 //循环队列的最大长度 typedef int QElemType; //队列元素类型 typedef struct { QElemType *base; //指向队列空间的指针 int front; //队头指针 int rear; //队尾指针 } SqQueue; //初始化循环队列 void InitQueue(SqQueue &Q) { Q.base = new QElemType[MAXQSIZE]; Q.front = Q.rear = 0; } //入队列 bool EnQueue(SqQueue &Q, QElemType e) { if ((Q.rear + 1) % MAXQSIZE == Q.front) return false; //队列已满 Q.base[Q.rear] = e; Q.rear = (Q.rear + 1) % MAXQSIZE; return true; } //出队列 bool DeQueue(SqQueue &Q, QElemType &e) { if (Q.front == Q.rear) return false; //队列为空 e = Q.base[Q.front]; Q.front = (Q.front + 1) % MAXQSIZE; return true; } //判断队列是否为空 bool QueueEmpty(SqQueue Q) { if (Q.front == Q.rear) return true; else return false; } //求队列长度 int QueueLength(SqQueue Q) { return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE; } //遍历输出队列 void QueueTraverse(SqQueue Q) { cout << "当前队列为："; if (Q.front == Q.rear) return; while (Q.front != Q.rear) { cout << Q.base[Q.front] << " "; Q.front = (Q.front + 1) % MAXQSIZE; } cout << endl; } int main() { SqQueue Q; InitQueue(Q); EnQueue(Q, 1); EnQueue(Q, 2); EnQueue(Q, 3); QueueTraverse(Q); QElemType e; DeQueue(Q, e); QueueTraverse(Q); cout << "队列长度为：" << QueueLength(Q) << endl; return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值