精华内容
下载资源
问答
  • // 循环队列#include #include "SeqQue.h"// 循环队列的基本运算/*const int maxsize = 20;typedef struct cycque{int data[maxsize];int front, rear;}CycQue;*/// 1. 初始化void InitQueue(CycQue CQ){CQ.front = ...

    // 循环队列

    #include

    #include "SeqQue.h"

    // 循环队列的基本运算

    /*

    const int maxsize = 20;

    typedef struct cycque

    {

    int data[maxsize];

    int front, rear;

    }CycQue;

    */

    // 1. 初始化

    void InitQueue(CycQue CQ)

    {

    CQ.front = ;

    CQ.rear = ;

    }

    // 2. 判断队空

    int EmptyQueue(CycQue CQ)

    {

    if(CQ.rear == CQ.front)

    return ;

    else

    return ;

    }

    // 3. 入队列

    int EnQueue(CycQue CQ, int x)

    {

    if((CQ.rear + )%maxsize == CQ.front)

    {

    printf("队列满\n");

    return ;

    }

    else

    {

    CQ.rear = (CQ.rear + )%maxsize;

    CQ.data[CQ.rear] = x;

    return ;

    }

    }

    // 4. 出队列

    int OutQueue(CyQue CQ)

    {

    if(EmptyQueue(CQ))

    {

    printf("队列空\n");

    return ;

    }

    else

    {

    CQ.front = (CQ.front + )%maxsize;

    return ;

    }

    }

    // 5.取队列首元素

    int GetHead(CycQue CQ)

    {

    if(EmptyQueue(CQ))

    {

    printf("队列为空\n");

    return ;

    }

    else

    {

    return CQ.data[(CQ.front + )%maxsize];

    /*

    说明:为了方便操作,规定front指向队列首元素的前一个单元,

    rear指向实际的队列尾元素单元。

    */

    }

    }

    // 循环队列的基本运算

    main()

    {

    }

    链队列

    #include

    #include "Lkqueue.h"

    /*

    // 链队列类型定义

    typedef struct LinkQueueNode

    {

    int data;

    struct LinkQueueNode *next;

    }LkQueNode

    typedef struct LkQueue

    {

    LkQueNode *front, *rear;

    }LkQue;

    */

    // 1. 队列的初始化

    void InitQueue(LkQue *LQ)

    {

    LkQueNode *temp;

    temp = (LkQueNode *)malloc(sizeof(LkQueNode));

    LQ->front = temp;

    LQ->rear = temp;

    (LQ->front)->next = NULL;

    }

    // 2. 判队列空

    int EmptyQueue(LkQue LQ)

    {

    if(LQ.rear == LQ.front)

    return ;

    else

    return ;

    }

    // 3. 入队列

    void EnQueue(LkQue *LQ, int x)

    {

    LkQueNode *temp;

    temp = (LkQueNode *)malloc(sizeof(LkQueNode));

    temp->data = x;

    temp->next = NULL;

    (LQ->rear)->next = temp; // 新节点入队列

    LQ->rear = temp; // 置新的队列尾节点

    }

    // 4. 出队列

    int OutQueue(LkQueue *LQ)

    {

    LkQueNode *temp;

    if(EmptyQueue(LQ))

    {

    printf("队列为空\n");

    return ;

    }

    else

    {

    temp = LQ->front->next; // 队列首元素

    (LQ->front)->next = temp->next;

    if(temp->next == NULL)

    LQ->rear = LQ->front; // 无首节点时,front和rear都指向头节点

    free(temp);

    return ;

    }

    }

    【Java】 大话数据结构(7) 循环队列和链队列

    本文根据一书,实现了Java版的循环队列.链队列. 队列:只允许在一端进行插入操作,而在另一端进行删除操作的线性表. 1.循环队列 队列的顺序储存结构:用数组存储队列,引入 ...

    JAVA该队列中的数组,圆阵队列,链队列

    /** * 文件名:QueueText.java * 时间:2014年10月22下午9:05:13 * 笔者:维亚康姆维修 */ package chapter3; /** * 类名:ArrayQue ...

    【数据结构(C语言版)系列三】 队列

    队列的定义 队列是一种先进先出的线性表,它只允许在表的一端进行插入,而在另一端删除元素.这和我们日常生活中的排队是一致的,最早进入队列的元素最早离开.在队列中,允许插入的一端叫做队尾(rear),允许 ...

    数据结构算法C语言实现(十一)--- 3.4队列的链式表示和实现

    一.简介 FIFO. 二.头文件 //3_4_part1.h /** author:zhaoyu email:zhaoyu1995.com@gmail.com date:2016-6-9 note:r ...

    数据结构Java实现07----队列:顺序队列&顺序循环队列、链式队列、顺序优先队列

    一.队列的概念: 队列(简称作队,Queue)也是一种特殊的线性表,队列的数据元素以及数据元素间的逻辑关系和线性表完全相同,其差别是线性表允许在任意位置插入和删除,而队列只允许在其一端进行插入操作在其 ...

    javascript实现数据结构与算法系列:队列 -- 链队列和循环队列实现及示例

    1 队列的基本概念 队列(Queue):也是运算受限的线性表.是一种先进先出(First In First Out ,简称FIFO)的线性表.只允许在表的一端进行插入,而在另一端进行删除. 队首(fr ...

    队列(FIFO)—循环队列、队列的链式存储

    1 队列的定义 队列是只允许在一端(队尾)进行插入操作,而在另一端(队头)进行删除操作的线性表. 2 队列的特点 1)先进先出是队列最大的特点,是应用中非常常见的模型,例如排队: 2)队列也属于线性表 ...

    队列(链式队列)----C语言

    链式队列----用链表实现,链式队列就是一个操作受限的单向链表,如果读者了解单向链表的建立过程,那理解链式队列就很容易了,先回顾一下单向链表的建立过程 (不熟悉单向链表的可以先看看另一片随笔,再回来看 ...

    c语言描述的链队列的基本操作

    #include #include #define ok 0 #define error 1 //链队列特点在于不仅有链的头指针和尾指针, ...

    随机推荐

    javaURL中文乱码的问题

    中文乱码在java中URLEncoder.encode方法要调用两次解决   一.场景: 1.我在客户端要通过get方式调用服务器端的url,将中文参数做utf-8编码,需要在js中两次的进行编码, ...

    C++动态内存分配

    C++动态内存分配1.堆内存分配 :C/C++定义了4个内存区间:代码区,全局变量与静态变量区,局部变量区即栈区,动态存储区,即堆(heap)区或自由存储区(free store). 堆的概念:通常定 ...

    解决:HotSeat短信图标提醒有误

    [操作步骤]正常收发短信.彩信. [测试结果]所有短信均已阅读,但在HOME界面的短信图标仍提示有一条短信未读.重启后仍存在. 经过分析,导致该情况的主要原因为当彩信已读的时候,launcher中进行 ...

    eclipse bookmark的使用

    为什么要使用bookmark 写代码一般不是从上往下写,经常在几个模块之间变换的写,你可能使用搜索功能ctrl+f,ctrl+c,这样查找位置将会变的非常痛苦. 因为重要的位置一般就那么几个,如定义部 ...

    解决iphone safari上的圆角问题

    -webkit-appearance : none ; /*解决iphone safari上的圆角问题*/

    【HDOJ】4455 Substrings

    5000ms的时限,还挺长的.算法是DP.思路是找到ans[1..n]的结果,然后Query就容易做了.问题是怎么DP?考虑:1 1 2 3 4 4 5w=1: 7, 7 = 1 * 7w=2: 10 ...

    i++与++i的区别

    i++与++i的意思都是i自身加1,不过这个两个语句却有很大的区别. ++i,就是直接在i上再加1,这个无需多解释. i++会稍微特殊些,他会在下次执行语句,再遇到i时,才会在i身上加1. 打个比方, ...

    详述USB OTG发展及协议标准

    USB On-The-Go 扩大了USB 的应用领域,将USB 从传统的PC 与外设通讯的模式,扩展到移动电子和嵌入式领域中,抛开主机PC,实现通常的外设与外设之间点对点(Point to Point ...

    2016年中国大学生程序设计竞赛(杭州)1006 Four Operations

    Four Operations Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)T ...

    《FPGA全程进阶---实战演练》第七章 让按键恢复平静

    1基础理论部分 A:“怎么按键按下去之后,结果不正常?”,B:“按键你消抖了吗?”A:“消什么抖,还要消抖?”,  B:“先检测按键变化,然后消抖过滤波动信号,最后输出稳定信号”,A:“我好像漏掉了什 ...

    展开全文
  • 牛客刷题笔记--(队列专项练习)

    千次阅读 2021-01-27 21:27:40
    知识点总结 图的拓扑排序 深度优先 关键路径算法用的辅助数据结构是栈 树的层序遍历 图的广度优先遍历用的数据结构是队列 ...1 循环队列的存储空间为 Q(1:100) ,初始状态为 front=rear=100 。经过一系列正常的入队

    知识点总结

    图的拓扑排序 深度优先 关键路径算法用的辅助数据结构是栈
    树的层序遍历 图的广度优先遍历用的数据结构是队列
    输入受限 的 双端队列 是指元素只能从 队列 的一 端输入 ,但可以从 队列 的两端 输出;
    输出受限 的 双端队列 是指只有一端可以进行出队操作而从两端都可以进行入队操作的 队列。
    求循环队列中的元素个数的公式为:(rear-front+size)%size,size是循环队列的容量
    堆最适合创建一个优先级队列

    循环队列的相关条件和公式:
    1.队空条件:rear=front
    2.队满条件:(rear+1) %QueueSIze=front,其中QueueSize为循环队列的最大长度
    注意一下,对于普通的循环队列,当栈满或者栈空时,都有front=rear,所以,我们为了区分,约定牺牲一个元素位置,这样的话(rear+1) %QueueSIze=front就可以判断队满了(那么判断队满就不能用条件rear=front了)

    题型

    循环队列
    判断队列元素个数
    输入受限 的 双端队列 出队列顺序
    输出受限 的 双端队列 出队列顺序
    循环队列队空队满条件

    刷题

    1 循环队列的存储空间为 Q(1:100) ,初始状态为 front=rear=100 。经过一系列正常的入队与退队操作后, front=rear=99 ,则循环队列中的元素个数为(D )

    1
    
    2
    
    99
    
    0100
    

    以下是循环队列的一些特性。当front=rear时,队列为空(front追到rear)或者为满(rear追到front)。

    在这里插入图片描述

    在循环队列中,用队尾指针 rear 指向队列中的队尾元素,用排头指针 front 指向排头元素的前一个位置。在循环队列中进行出队、入队操作时,头尾指针仍要加 1 ,朝前移动。只不过当头尾指针指向向量上界时,其加 1 操作的结果是指向向量的下界 0 。由于入队时尾指针向前追赶头指针,出队时头指针向前追赶尾指针,故队空和队满时,头尾指针均相等。故本题答案为 D 选项。

    2 假设以数组A[60]存放循环队列的元素,其头指针是front=47,当前队列有50个元素,则队列的尾指针值为(B)

    3
    
    37
    
    97
    
    50
    

    队列中元素的个数: (rear-front+QueueSize)%QueueSize

    根据题意得:(rear - 47 + 60)% 60 = 50

    => rear = 37 选B

    3 循环队列的存储空间为 Q(1:40) ,初始状态为 front=rear=40 。经过一系列正常的入队与退队操作后, front=rear=15 ,此后又退出一个元素,则循环队列中的元素个数为(A )

    39,或0且产生下溢错误
    
    14
    
    40
    
    15
    

    front==rear代表着队列满,或者空。然后又退出去了一个数据,所以当为空的时候,就会产生下溢。为满的时候,就是总个数-1也就是39个

    4 用链接方式存储的队列,在进行删除运算时( D )。

    仅修改头指针
    
    仅修改尾指针
    
    头、尾指针都要修改
    
    头、尾指针可能都要修改
    

    在有头结点的链队列的出队操作中,一般只需修改队头指针,但当原队列中只有一个结点时,该结点既是队头也是队尾,故删去此结点时亦需修改队尾指针,使其指向头结点,且删去此结点后队列变空。

    一般情况下只修改头指针,但是,当删除的是队列中最后一个元素时,队尾指针也丢失了,因此需对队尾指针重新赋值。

    本题既考察了队列的先进先出的特性,又需要考虑删除时队列的不同状态。
    1> 当有多于一个节点时,链表表示的队列的删除操作只需要修改头指针即可,将头指针定义为head=head.next 此时不需要修改尾指针;
    2> 当队列只有一个节点时,该节点既是头又是尾,如果head==tail 则需要修改尾指针将队列置空。

    5 队列{a,b,c,d,e}依次入队,允许在其两端进行入队操作,但仅允许在一端进行出队操作,则不可能得到的 出队 序 列 是(C)

    b, a, c, d, e
    
    d, b, a, c, e
    
    d, b, c, a, e
    
    e, c, b, a, d
    

    题干说可以两端入队。一端出队。 a选项:b a c d e☞左入a,右入b,左入c,左入d,左入e。出队端为右端(或者整个完全相反也可以。) b选项:d b a c e☞左入a,右入b,左入c,右入d,左入e。出队端为右端(或者整个完全相反也可以。) d选项:e c b a d☞左入a,左入b,左入c,右入d,左入e。出队端为左端(或者整个完全相反也可以。)

    6 STL中的优先队列是采用什么数据结构来实现的?(A)

    堆
    
    队列
    
    栈
    
    图
    

    STL之优先队列
    priority_queue优先队列,也就是原来我们学过的堆,按照自己定义的优先级出队时。默认情况下底层是以Vector实现的heap。
    只有入队、出队、判空、大小的操作,并不具备查找功能。

    STL中的priority_queue,它就是用堆实现的,插入或删除不需要排序,只是一个调整堆的过程。

    7 已知输入序列为abcd经过输出受限的双向队列后能得到的输出序列有(BD)

    dacb
    
    cadb
    
    dbca
    
    bdac
    
    以上答案都不对
    

    先说结论:
    对于…a…b…c…d…的输入序列(…代表其他任意元素),经过输出受限的双向队列后,
    有两种类型的序列是不存在的:
    …d…b…c…a…
    …d…a…c…b…
    也就是不能出现c夹在a和b中间的情况。

    证明过程:
    因为a、b、c先于 d入队且d先于a、b、c出队,所以当d出队时a、b、c还在队中。
    对于a、b、c而言: a,b先入队,此时a和b的排列顺序为ab或ba,所以当c入队时,只能排在在ab或ba的两端。
    即不能出现c夹在a和b中间的情况,
    也就是不能出现…d…b…c…a…和…d…a…c…b…这两种情况。
    证明完成。

    8 最大容量为n的循环队列,队尾指针是rear,队头是front,则队满的条件是(A)。

    (rear+1) MOD n==front
    
    rear==front
    
    rear+1==front
    
    (rear-1) MOD n==front
    

    9 下列叙述中正确的是(A )。

    在循环队列中,队头指针和队尾指针的动态变化决定队列的长度
    
    在循环队列中,队尾指针的动态变化决定队列的长度
    
    在带链的队列中,队头指针与队尾指针的动态变化决定队列的长度
    
    在循环队列中,队头指针一定小于队尾指针
    

    【解析】在栈中,栈底保持不变,有元素入栈,栈顶指针增加;有元素出栈,栈顶指针减小。在循环队列中,队头指针和队尾指针的动态变化决定队列的长度。在循环链表中,前一个结点指向后一个结点,而最后一个结点指向头结点,只有头结点是固定的。线性链表中,由于前一个结点包含下一个结点的指针,尾结点指针为空,要插入删除元素,只需要改变相应位置的结点指针即可,头指针和尾指针无法决定链表长度。故本题答案为 A 选项。

    C:链式队列,元素存储空间不一定连续,无法直接通过队头和队尾获得其长度

    10 用链接方式存储的队列,在进行插入运算时 ( D ).

    仅修改头指针
    
    头、尾指针都要修改
    
    仅修改尾指针
    
    头、尾指针可能都要修改
    

    一般情况下,仅需修改队尾指针;
    但当队列为空时,插入元素时,队头和队尾指针都需修改

    11 最大容量为n的循环队列,队尾指针是rear,队头是front,则队空的条件是(B)

    (rear+1) MOD n=front
    
    rear=front
    
    rear+1=front
    
    (rear-1) MOD n=front
    
    循环队列的相关条件和公式:
    1.队空条件:rear==front
    2.队满条件:(rear+1) %QueueSIze==front,其中QueueSize为循环队列的最大长度
    3.计算队列长度:(rear-front+QueueSize)%QueueSize
    4.入队:(rear+1%QueueSize
    5.出队:(front+1%QueueSize
    

    在循环队列中,当队列为空时,有front=rear,而当所有队列空间全占满时,也有front=rear。为了区别这两种情况,规定循环队列最多只能有MaxSize-1个队列元素。

    当循环队列中只剩下一个空存储单元时,队列就已经满了。因此,队列判空的条件时front=rear,而队列判满的条件时front=(rear+1)%MaxSize

    在这里插入图片描述

    12 在循环队列中, 若尾指针 rear 大于头指针 front, 其元素个数为 rear- front。正确

    13已知循环队列存储在一维数组A[0…n-1]中,且队列非空时 front 和 rear 分别指向队头和队尾元素。若初始时队列为空,且要求第 1 个进入队列的元素存储在 A[0]处,则初始时 front和 rear 的值分别是( B)。

    00
    
    0, n-1
    
    n-10
    
    n-1, n-1
    

    首先根据循环队列的公式,插入元素,front不变,rear=(rear+1)%n。在本题中,即(rear+1)%n=0,可得rear=n-1。此时队列中只有一个元素,则front与rear应该指向同一个位置,即front也应该为0。
    综上,front=0, rear=n-1

    14 设循环队列的容量为50(序号从0到49),现经过一系列的入队和出队运算后,有 front=16,rear=5(rear指向队尾元素的后一位置),当前循环队列中元素个数为( B)

    11
    
    39
    
    40
    
    12
    

    分析:现在5-15是没有元素的,rear指向队尾元素的后一位置
    求循环队列中的元素个数的公式为:(rear-front+size)%size,size是循环队列的容量

    15 有一个虚拟存储系统,若进程在内存中占3页(开始时内存为空),若采用先进先出(FIFO)页面淘汰算法,当执行如下访问页号序列后1,2,3,4,5, 1,2,5,1,2,3,4,5,会发生多少缺页?(10次)

    1、访问1,缺页,调入1,内存中为 1, ,;
    2、访问2,缺页,调入2,内存中为 1,2,;
    3、 访问3,缺页,调入3,内存中为 1,2,3;
    4、 访问4,缺页,调入4,淘汰1,内存中为 4,2,3;
    5、 访问5,缺页,调入5,淘汰2,内存中为 4,5,3;
    6、 访问1,缺页,调入1,淘汰3,内存中为 4,5,1;
    7、 访问2,缺页,调入2,淘汰4,内存中为 2,5,1;
    8、 访问5,不缺页,内存中为 2,5,1;
    9、 访问1,不缺页,内存中为 2,5,1;
    10、 访问2,不缺页,内存中为 2,5,1;
    11、访问3,缺页,调入3,淘汰5,内存中为 2,3,1;
    12、访问4,缺页,调入4,淘汰1,内存中为 2,3,4;
    13、访问5,缺页,调入5,淘汰2,内存中为 5,3,4;

    16 在下列链队列Q中,元素a出队的操作序列为(B) (提示:p是出队操作所用的辅助节点 )
    在这里插入图片描述

    p=Q.front->next; p->next= Q.front->next;
    
    p=Q.front->next; Q.front->next=p->next;
    
    p=Q.front->next; Q.front->next=p;
    
    p=Q.front->next; Q.front=p->next;
    

    带头节点,所以Q.front->next指向a
    先断开,再链接

    17 下列叙述中正确的是(B )。

    循环队列是队列的一种链式存储结构
    
    循环队列是队列的一种顺序存储结构
    
    循环队列是非线性结构
    
    循环队列是一种逻辑结构
    

    在这里插入图片描述
    18 对于序列( 12 , 13 , 11 , 18 , 60 , 15 , 7 , 19 , 25 , 100 ),用筛选法建堆,必须从值为 C__ 的数据开始建初始堆

    100
    
    12
    
    60
    
    15
    

    有n个元素的序列,若使用筛选法建堆,则从位置为n/2取下整的元素开始建堆 (从最后一个结点的父亲结点开始,所以是n/2)

    按原顺序放到完全二叉树中,从上到下,从左到右,找到最后一个有儿子的节点开始

    若元素地址从零开始,则n/2-1。若由1开始,则n/2。如果题目中未说明由零开始或是1开始,默认由零开始。

    筛选建堆就是从下至上的下滤法建堆,将序列按照顺序组成一棵二叉树,从叶子节点到根节点,依次进行下滤操作;
    但是很明显,叶子节点不需要下滤,所以就是从第一个非叶子节点开始。
    12
    13 11
    18 60 15 7
    19 25 100
    所以其实就是从60这个节点开始了,因为加粗的几个节点都已经不用下滤了

    19 有一个队列X,在X的两端都可以入队,但只允许在X的一端出队,在任意时间都可以做入队和出队操作。将序列{A,B,C,D,E}依次入队,则得到的出队序列可能有(ABD)

    {B,A,C,D,E}

    {D,B,A,C,E}

    {D,B,C,A,E}

    {E,C,B,A,D}

    不管如何,B都是第二个进队的,所以出队时一定与A挨着,C在AB左右均可,以此类推。选ABD。

    20 以下开源软件中经常被用作队列的是哪个?BD

    MongoDB

    Redis

    Memcached

    kafka

    MongoDB 是非关系型数据库
    Memcached 是分布式缓存系统

    21 设指针变量fron t 表示链式队列的队头指针,指针变量rear表示链式队列的队尾指针,指针变量s指向将要入队列的结点X,则入队列的操作序列为(C)。

    front->next=s;front=s;
    
    s->next=rear;rear=s;
    
    rear->next=s;rear=s;
    
    s->next=front;front=s;
    

    先让rear的下一个指向目标变为s,再把rear更新为s

    22 设顺序循环队列Q[0,M-1]的头指针和尾指针分别为F和R,头指针F总是指向队头元素的前一位,尾指针R总是指向队尾元素的当前位置,则该循环队列职工的元素个数为(B )?

    (F-R)%M
    
    (R-F+M)%M
    
    (F-R+M)%M
    
    R-F-1
    

    书中定义的队列长度为:(rear-front++QueueSize)%QueueSize 1.rear: 定义中是指向末尾元素的下一个位置, 本题中是直接指向末尾元素, 所以将rear向后移动一个位置, R-1 2.front:定义中是指向首元素, 而本题中是指向首元素的前一个元素, 因此向后移动一个位置, F-1 rear = R-1 front = F-1 所以: [ (R - 1) - ( F - 1) + M]%M = (R-F+M)%M

    23 现有一循环队列,其队头指针为front,队尾指针为rear;循环队列长度为N。其队内有效长度为?(假设队头不存放数据) B

    (rear - front + N) % N + 1
    
    (rear - front + N) % N
    
    (rear - front) % (N + 1)
    
    (rear - front + N) % (N - 1)
    

    24 循环队列存储在数据A[0…m]中,则入队时的操作为___D___ 。

    rear=rear+1
    
    rear=(rear+1)%(m-1)
    
    rear=(rear+1)%m
    
    rear=(rear+1)%(m+1)
    

    入队(rear+1)%QueueSize
    QueueSize=m+1

    25 大小为MAX的循环队列中,f为当前对头元素位置,r为当前队尾元素位置(最后一个元素的位置),则任意时刻,队列中的元素个数为 B

    r-f
    
    (r-f+MAX+1)%MAX
    
    r-f+1
    
    (r-f+MAX)%MAX
    

    【这一题有点陷阱】我来解释下为什么是B而不是D
    教材上说的 (也是大家记住的)求队列公式为: (rear-front+Max)%Max
    该公式中的 rear指向队尾元素的下一个位置 ,而本题中 r 指 向队尾元素位置

    在这里插入图片描述

    展开全文
  • // 头指针后移,即为“删除元素”,实则值还,等新值值进来进行覆盖处理 printf("循环队列元素成功出队!"); return 0; } void ShowQueue(SqQueue *Q) { // 若队列不为空,展示当前循环中的存储情况 if (Q->...

    一、参考知识

    1. malloc()函数:动态分配内存空间

    二、代码部分

    1. 头文件:circular_queue.h

    // 
    // Project: Circular_Queue
    // File: circular_queue.h
    // IDE: CLion
    // Created by RichardLau_Cx on 2021/5/19.
    //
    
    /*************************************************************
        循环队列操作的实现  头文件
    **************************************************************/
    
    //#ifndef CIRCULAR_QUEUE_CIRCULAR_QUEUE_H
    //#define CIRCULAR_QUEUE_CIRCULAR_QUEUE_H
    //
    //#endif //CIRCULAR_QUEUE_CIRCULAR_QUEUE_H
    
    #define MAXQSIZE 100  // 定义循环队列的最大长度
    
    typedef struct {
        int *base;  // 循环队列的存储空间,假设队列中存放的是整型数
        int front;  // 指示队头,称为队头指针
        int rear;  // 指示队尾,称为队尾指针
    }SqQueue;
    
    
    // 创建空的循环队列
    int InitQueue(SqQueue *Q);
    
    // 元素入循环队列
    int EnQueue(SqQueue *Q, int e);
    
    // 元素出循环队列
    int DelQueue(SqQueue *Q, int *e);
    
    // 展示队列
    void ShowQueue(SqQueue *Q);
    
    

    2. 主函数文件:main.cpp

    //
    // Project: Circular_Queue
    // File: functional_operation.cpp
    // IDE: CLion
    // Created by RichardLau_Cx on 2021/5/19.
    //
    
    #include <iostream>
    #include "circular_queue.h"
    
    
    int main() {
        SqQueue Q;  // 定义全局循环队列
        int opt;  // 功能选项
        int goOn=1;  // 是否继续使用
        int e;  // 元素值
    
        while (goOn) {
            printf("\n欢迎来到循环队列的世界,请选择你想要的操作:\n"
                   "1. 创建一个空的循环队列\n"
                   "2. 特定元素入队循环队列\n"
                   "3. 出队循环队列\n"
                   "4. 展示当前循环队列中的存储情况\n\n");
    
            scanf("%d", &opt);
    
            switch (opt) {
                case 1:
                    InitQueue(&Q);  // 传入地址,给指针变量接收
    
                    break;
    
                case 2:
                    printf("\n要入队的元素值:");
                    scanf("%d", &e);
                    EnQueue(&Q, e);
    
                    break;
    
                case 3:
                    DelQueue(&Q, &e);
    
                    break;
    
                case 4:
                    ShowQueue(&Q);
    
                    break;
            }
    
            std::cout << "\n还要继续使用吗(是为1,否为0)?\n" << std::endl;
            scanf("%d", &goOn);
        }
    
        return 0;
    }
    
    

    3. 功能操作文件:functional_operation.cpp

    // 
    // Project: Circular_Queue
    // File: functional_operation.cpp
    // IDE: CLion
    // Created by RichardLau_Cx on 2021/5/19.
    //
    
    #include "circular_queue.h"
    #include <cstdlib>
    #include <stdio.h>
    
    int InitQueue(SqQueue *Q)
    {  // 创建容量为MAXQSIZE的空队列,若成功返回0,否则返回-1
        Q->base = (int *)malloc(MAXQSIZE * sizeof(int));
    
        if (!Q->base)
        {  // 存储空间分配失败
            return -1;
        }
    
        Q->front = 0;
        Q->rear = 0;
    
        printf("循环队列成功创建!\n");
    
        return 0;
    }
    
    
    int EnQueue(SqQueue *Q, int e)
    {  // 元素e入队,若成功,则返回0,否则返回-1
        if ((Q->rear+1) % MAXQSIZE == Q->front)  // 尾指针的下一个位置为头指针
        {  // 循环队列已满
            return -1;
        }
    
        Q->base[Q->rear] = e;  // 用数组代替指针赋值(此时Q->rear相当于索引)
        Q->rear = (Q->rear + 1) % MAXQSIZE;
    
        return 0;
    }
    
    
    int DelQueue(SqQueue *Q, int *e)
    {  // 若队列不空,则删除队头元素,由参数e带回其值,并且返回0,否则返回-1
        if (Q->rear == Q->front)  // 尾指针和头指针在同一个位置
        {  // 循环队列为空
            return -1;
        }
    
        *e = Q->base[Q->front];  // 给e赋值
        Q->front = (Q->front + 1) % MAXQSIZE;  // 头指针后移,即为“删除元素”,实则值还在,等新值值进来时,进行覆盖处理
    
        printf("循环队列元素成功出队!");
    
        return 0;
    }
    
    
    void ShowQueue(SqQueue *Q)
    {  // 若队列不为空,展示当前循环中的存储情况
        if (Q->rear == Q->front)
        {
            return;
        }
    
        // 从队头遍历到队尾
        for (int i = Q->front; i < Q->rear; ++i)
        {
            printf("%d ", Q->base[i]);
        }
    }
    

    三、配套资源

    展开全文
  • 循环队列

    2021-07-15 02:42:30
    存储其中的队列称为循环队列(Circular Queue)。循环队列是把顺序队列首尾相连,把存储队列元素的表从逻辑上看成一个环,成为循环队列。中文名循环队列外文名Circular Queue领域实现方式有关术语特点大小固定循环...

    为充分利用向量空间,克服"假溢出"现象的方法是:将向量空间想象为一个首尾相接的圆环,并称这种向量为循环向量。存储在其中的队列称为循环队列(Circular Queue)。循环队列是把顺序队列首尾相连,把存储队列元素的表从逻辑上看成一个环,成为循环队列。

    中文名

    循环队列

    外文名

    Circular Queue

    领    域实现方式

    有关术语

    特    点

    大小固定

    循环队列简介

    编辑

    语音

    循环队列就是将队列存储空间的最后一个位置绕到第一个位置,形成逻辑上的环状空间,供队列循环使用。在循环队列结构中,当存储空间的最后一个位置已被使用而再要进入队运算时,只需要存储空间的第一个位置空闲,便可将元素加入到第一个位置,即将存储空间的第一个位置作为队尾。[1]

    循环队列可以更简单防止伪溢出的发生,但队列大小是固定的。

    在循环队列中,当队列为空时,有front=rear,而当所有队列空间全占满时,也有front=rear。为了区别这两种情况,规定循环队列最多只能有MaxSize-1个队列元素,当循环队列中只剩下一个空存储单元时,队列就已经满了。因此,队列判空的条件是front=rear,而队列判满的条件是front=(rear+1)%MaxSize。[2]

    循环队列基本操作

    编辑

    语音

    // 队列的顺序存储结构(循环队列)

    #define MAX_QSIZE 5 // 最大队列长度+1

    typedef struct {

    int *base; // 初始化的动态分配存储空间

    int front; // 头指针,若队列不空,指向队列头元素

    int rear; // 尾指针,若队列不空,指向队列尾元素的下一个位置

    } SqQueue;

    // 构造一个空队列Q

    SqQueue* Q_Init() {

    SqQueue *Q = (SqQueue*)malloc(sizeof(SqQueue));

    // 存储分配失败

    if (!Q){

    exit(OVERFLOW);

    }

    Q->base = (int *)malloc(MAX_QSIZE * sizeof(int));

    // 存储分配失败

    if (!Q->base){

    exit(OVERFLOW);

    }

    Q->front = Q->rear = 0;

    return Q;

    }

    // 销毁队列Q,Q不再存在

    void Q_Destroy(SqQueue *Q) {

    if (Q->base)

    free(Q->base);

    Q->base = NULL;

    Q->front = Q->rear = 0;

    free(Q);

    }

    // 将Q清为空队列

    void Q_Clear(SqQueue *Q) {

    Q->front = Q->rear = 0;

    }

    // 若队列Q为空队列,则返回1;否则返回-1

    int Q_Empty(SqQueue Q) {

    if (Q.front == Q.rear) // 队列空的标志

    return 1;

    else

    return -1;

    }

    // 返回Q的元素个数,即队列的长度

    int Q_Length(SqQueue Q) {

    return (Q.rear - Q.front + MAX_QSIZE) % MAX_QSIZE;

    }

    // 若队列不空,则用e返回Q的队头元素,并返回OK;否则返回ERROR

    int Q_GetHead(SqQueue Q, int &e) {

    if (Q.front == Q.rear) // 队列空

    return -1;

    e = Q.base[Q.front];

    return 1;

    }

    // 打印队列中的内容

    void Q_Print(SqQueue Q) {

    int p = Q.front;

    while (Q.rear != p) {

    cout <

    p = (p + 1) % MAX_QSIZE;

    }

    }

    // 插入元素e为Q的新的队尾元素

    int Q_Put(SqQueue *Q, int e) {

    if ((Q->rear + 1) % MAX_QSIZE == Q->front) // 队列满

    return -1;

    Q->base[Q->rear] = e;

    Q->rear = (Q->rear + 1) % MAX_QSIZE;

    return 1;

    }

    // 若队列不空,则删除Q的队头元素,用e返回其值,并返回1;否则返回-1

    int Q_Poll(SqQueue *Q, int &e) {

    if (Q->front == Q->rear) // 队列空

    return -1;

    e = Q->base[Q->front];

    Q->front = (Q->front + 1) % MAX_QSIZE;

    return 1;

    }

    循环队列条件处理

    编辑

    语音

    循环队列中,由于入队时尾指针向前追赶头指针;出队时头指针向前追赶尾指针,造成队空和队满时头尾指针均相等。因此,无法通过条件front==rear来判别队列是"空"还是"满"。

    解决这个问题的方法至少有两种:

    ① 另设一布尔变量以区别队列的空和满;

    ②另一种方式就是数据结构常用的: 队满时:(rear+1)%n==front,n为队列长度(所用数组大小),由于rear,front均为所用空间的指针,循环只是逻辑上的循环,所以需要求余运算。如图1所示情况,队已满,但是rear(5)+1=6!=front(0),对空间长度求余,作用就在此6%6=0=front(0)。

    ae24e1d58d6514b9f190b083c417fd7e.png

    图1

    类型定义采用环状模型来实现队列,各数据成员的意义如下:

    front指定队首位置,删除一个元素就将front顺时针移动一位;

    rear指向元素要插入的位置,插入一个元素就将rear顺时针移动一位;

    count存放队列中元素的个数,当count等于MaxQSize时,不可再向队列中插入元素。

    循环队列队列

    编辑

    语音

    数据结构分为线性结构和非线性结构,队列和线性表都是线性结构。线性表是由n 个数据元素组成的有限序列,该序列有惟一的“第一个”和惟一的“最后一个”数据元素;除了 “第一个”和“最后一个”之外,队列中的每个数据元素都只有一个直接前驱和一个直接后继。线性表的插入和删除操作可以在表中任意位置进行。队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队头。队列中没有元素时,称为空队列。

    队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队,从队列中删除一个队列元素称为出队。因为队列只允许在一端插入,在另一端删除,所以只有最早进入队列的元素才能最先从队列中删除,故队列又称为先进先出(FIFO—first in first out)线性表。

    词条图册

    更多图册

    参考资料

    1.

    杨非.C语言程序设计应试辅导: 二级:清华大学出版社,2006

    展开全文
  • 循环队列的基本操作详细讲解实验学时:2实验类型:(设计型)一、实验目的1. 理解并掌握队列的逻辑结构和顺序存储结构,了解循环队列的特点;2. 掌握循环队列中基本操作的相关算法;3. 编程实现相关算法;4. 学会利用...
  • 我们的生活中有需要用到很多队列的才能出来的,可以说时间相关的问题一般都涉及排队,本文详解C语言循环队列的实现事例,...队列只允许后端(称为rear)进行插入操作,前端(称为front)进行删除操作。循环队列...
  • Java实现循环队列

    2021-03-13 03:42:26
    一、分析队列是一种先进先出的...它的基本操作如下:1、初始化循环队列2、销毁循环队列3、清空循环队列4、检测循环队列是否为空5、返回循环队列的元素个数6、返回循环队列头元素7、向队尾插入元素8、删除并返回队...
  • 队列是一种特殊的线性表,特殊之处在于它只允许表的前端(front)进行删除操作,而表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队头。...
  • 数据结构专升本学习,队列篇(顺序队和循环队列) ...队列是一种特殊的线性表,特殊之处在于它只允许表的前端(front)进行删除操作,而表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进
  • 1.理解栈与队列的结构特征和运算特征,以便实际问题背景下灵活运用。 2.了解复杂问题的递归算法设计。 实验类型及学时 验证性 2学时 实验内容和步骤 实验内容: 1.利用辅助栈进行队列的逆置 2.利用辅助...
  • 在队列中,允许插入的一端称队尾(Rear),允许删除的一端则称为队头(Front)。 队列在程序设计中也经常出现。一个最典型的例子就是操作系统中的作业排队。允许多道程序运行的计算机系统中,同时有几个作业...
  • 队列分为顺序队列和循环队列,顺序队列的实现...循环队列之前,我们先讲一下顺序队列的假溢出。 1 顺序队列的假溢出 1️⃣:初始化空队列,q -> front = q -> rear = 0。 2️⃣:入队a1、a2、a3,q -> fr
  • (1)栈是一种运算受限的线性表,其限制是仅允许表的一端进行插入和删除运算。人们把此端称为栈顶,栈顶的第一个元素被称为栈顶元素,相对地,把另一端称为栈底。向一个栈插入新元素又称为进栈或入栈,它是把该元素...
  • 队列是插入位置和删除位置受限制的线性表,它只能一端进行插入,而另一端进行删除元素,其只允许插入的一端称为队尾,只允许删除的一端称为队首。由于队列中的元素插入与删除时,两端的都要变化,所以需要两个...
  • 循环队列 队首指针 front 队尾指针 rear 1.初始化:front = 0 rear = 0 2.队列为空: front = rear 3.队满:(rear + 1) % MaxSize == front 4.入队:将新元素插入rear位置,然后rear+1 5.出队:删除front所指的元素...
  • 实现循环队列的入队,出队等基本操作循环队列的基本操作??一、实验目的 1. 理解并掌握队列的逻辑结构和顺序存储结构,了解循环队列的特点; 2. 掌握循环队列中基本操作的相关算法; 3. 编程实现相关算法; 4. ...
  • 循环队列的基本实现

    2021-05-22 11:23:46
    队列(Queue)是一种先进先出(FirstInFirstOut,FIFO)的线性表,只允许表的前端(front)进行删除操作,而表的后端(rear)进行插入操作。 二、队列的溢出 顺序队列中的溢出现象: (1) "下溢"现象:当队列...
  • 因为它删除元素是队头,而插入元素是队尾,就像这样: 我们每插入一个数据,队尾指针就向后移一位,每删除一个数据队尾指针就向前移动一位,如我们删除一个数据就得到下图: 得到: 但是这样我们会发现这样...
  • 数组实现循环队列

    2021-01-22 22:18:30
    实际使用队列时,为了使队列空间能重复使用,往往对队列的使用方法稍加改进:无论插入或删除,一旦rear指针增1或front指针增1 超出了所分配的队列空间,就让它指向这片连续空间的起始位置。可以解决假溢出问题。...
  • #include"stdio.h"#include"stdlib.h"//这... //定义一个队列元素类型,这种编程思路很好,程序有扩展空间//声明一个有关循环队列的数据块,注意每个元素的意义!struct Queue{ElemType *base;//数据类型头指针int f...
  • 概述:只允许表的一端进行元素插入,另一端进行元素删除,允许插入的一端称为队尾(rear),允许删除的一端称为队头(frout)。 先进先出(First In First Out),简称FIFO 图示: 顺序循环队列 概述:两个...
  • 它只允许表的一端进行插入,另一端删除元素。 允许插入的一端成为队尾,允许删除的一端成为队头 循环队列的顺序表示和实现: 队列有顺序表示和链式表示两种方式,我们此处用顺序表示 队列的顺序存储结构: ...
  • 队列 队列和栈一样,是一种操作受限制的线性表。...为了解决这个问题,设计了循环队列 循环队列 为了实现空间的复用,关键是数组下标索引的循环利用 首先设置 front 、rear 指针来表示数组下标索引 为了解决循环
  • JAVA-循环队列

    2021-04-23 21:28:27
    首先,先来理一下思路所谓的顺序储存就是用数组来储存数据JAVA和C语言不同,他没有指针,所以我们需要创建两个类似于指针的索引,用他们对数组进行操作:定义一个front变量,让它一直指向队列中有效数据的第一个元素...
  • 循环队列的参考视频:https://www.bilibili.com/video/BV1nJ411V7bd?p=60 问题:什么是顺序队列的假...解决假上溢的方法-引入循环队列 把stack[0] 接queue[MAXQSIZE-1]之后,若rear+1 == MAXQSIZE,则令rear=0; 解.
  • 队列(Queue)简称队,也是一种操作受限的线性表,只允许表的一端进行插入,而另一端进行删除。向队列中插入元素称为入队或者进队,删除元素称为出队或者离队。特点是先进先出。如下所示 2.队列常见的基本操作 ...
  • 队列是一种特殊的线性表,特殊之处在于它只允许表的前端(front)进行删除操作,而表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队...
  • 指针和队列元素之间关系不变,如图6(a)所示循环队列中,队列头元素J3,队列尾元素是J5,之后J6、J7和J8相继插入,则队列空间均被占满,如图6(b)所示,此时Q.front=Q.rear;反之,若J3、J4和J5相继从图6(a)的队列中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,113
精华内容 16,445
关键字:

循环队列在进行删除运算时