精华内容
下载资源
问答
  • - PAGE PAGE 2 欢迎下载 实验四 队列循环队列的创建添加和删除操作 1实验目的掌握循环队列的基本操作并对其进行简单应用 2实验内容 假设循环队列最大长度为7现在依次将以下数据入队列{753924}接着进行3次出队列的...
  • 循环队列长度公式推导

    千次阅读 2021-07-15 16:55:50
    一、队列长度公式 队列长度=(Q.rear+MaxSize-Q.front)%MaxSize 二、队列长度公式各个变量意义 以上各个变量的意义如下: Q.rear:队尾。指向数列队尾元素的下一个空间。 Q.front:队头。指向数列队头元素。 ...

    一、循环队列长度公式

    队列长度=(Q.rear+MaxSize-Q.front)%MaxSize

    二、队列长度公式各个变量意义

    以上各个变量的意义如下:

    Q.rear:队尾。指向数列队尾元素的下一个空间

    Q.front:队头。指向数列队头元素。

    MaxSize:队列的最大长度。如队列Q.data[10]的表示Q.data[0]~Q.data[9]一共十个元素。

    三、循环队列相关知识说明

    1、初始条件:Q.front==Q.rear==0;

    2、进队操作:队列没满时,先将值送到队尾,再将队尾指针加1。即Q.data[Q.rear],Q.rear=(Q.rear+1)%MaxSize;

    3、出队操作:队列不空时,先取队头元素,再讲队头元素加一。即x=Q.data[Q.front],Q.front=(Q.front+1)%MaxSize;

    4、判断队列是否为空:Q.front==Q.rear,注意这里队头和队尾不一定是指向0号元素。举个例子,初始时Q.front==Q.rear==0,假如我先在Q.data[0]存入一个数,这时Q.front==0,而Q.rear==1。在这个前提下我们再进行出队操作,则此时Q.front==Q.rear==1,队列为空。

    5、判断队列是否满了:(Q.rear+1)%MaxSize==Q.front。我们要知道一个前提,即队列如果有十个单元,则我们只能使用9个单元,当队尾指针指向最后一个空单元时,则认为队列已满。这虽然牺牲了一个单元,但也避免了判空条件的冲突。我们想一想,假设 MaxSize=3,如果三个单元都装入元素,那Q.rear的值怎么处理,如果Q.front==Q.rear==0的话不是和判空操作冲突了吗?如果Q.rear==2,那不是和进队操作的进队后队尾指针加一的操作冲突了吗?所以为了操作方便,我们默认牺牲一个空间。

     6、Q.rear一定大于Q.front吗?这肯定不对。我们在进队的时候也可以进行出队操作。

    如下图所示,当队列满时,如果我们进行出队操作,则Q.front>0。此时队列又变为不满的操作,我们可以继续进行进队操作,则Q.rear会从Q.data[MaxSize-1](即末尾)回到开头。就像下图这样。

     四、队列长度公式推导。

    由上面介绍的队列的知识,我们可以知道Q.rear有大于、小于和等于Q.front三种情况。

    以下推导假设MaxSize=10;

    1、Q.rear>Q.front

    假设Q.rear=5,Q.front=2,则现在队列占得单元有Q.data[2]、Q.data[3]、Q.data[4]三个,那么队列长度L=Q.rear-Q.front=3。

    2、Q.rear=Q.front

    假设Q.rear=5,Q.front=5。我们知道Q.rear是一定指向空单元的,

    所以队列长度L=Q.rear-Q.front=0;

    3、Q.rear<Q.front

    假设Q.rear=3,Q.front=5,那么队列占得单元有Q.front开头的Q.data[5]、Q.data[6]、Q.data[7]...Q.data[9]5个单元,再加上Q.rear往下数的Q.data[2]、Q.data[1]、Q.data[0]三个单元,一共有8个单元。则MaxSize-Q.front=5,MaxSize-Q.front+Q.rear=8,

    所以队列长度L=MaxSize-Q.front+Q.rear;


    3的结果我们将变量位置变一下,则L=Q.reare-Q.front+MaxSize;

    这时我们发现3的结果不就是在1和2的结果上加了一个MaxSize吗。根据数学取余的性质,

    (x+ky)%y=x(注:x<y,k∈N),因此综上所述,队列长度公式可以写成:

    L=(Q.reare-Q.front+MaxSize)%MaxSize

    展开全文
  • 循环队列和顺序队列  队列的存储实现方式有哪些? 顺序存储(数组)和链式存储(链表),此博文描述的是数组的实现(后续更新链表实现)  代码实现 初始化队列:初始化一个size长度的队列,队列的值都为0 判断队列...
  • 实现循环队列,适合数据结构的小白~
  • 622. 设计循环队列 设计你的循环队列实现。...MyCircularQueue(k): 构造器,设置队列长度为 k 。 Front: 从队首获取元素。如果队列为空,返回 -1 。 Rear: 获取队尾元素。如果队列为空,返回 -1 。 enQ
  • 队列定义是这样的 #define MAXSIZE 10 typedef struct{ ElemType data[MAXSIZE]; int front,rear;...一直rear++便到达索引最大的位置,这个时候队列就满了不能再入队元素了吗? 并不,如果同时也一

    队列定义是这样的

    #define MAXSIZE 10
    typedef struct{
    	ElemType data[MAXSIZE];
    	int front,rear;
    } SeqQueue;
    

    一个队列 = 一个存放元素的数组 + 一个队头指针 + 一个队尾指针

    front:控制出队
    rear:控制入队

    我们先做个规定:
    front指向队头元素
    rear指向队尾元素的下一个元素(当然也可以让它直接指向队尾元素,只是在某些代码上需要相应的改动,但思想不变)

    初始我们让rear = front = data[0]

    元素出队:front++
    元素入队:rear++

    一直rear++便到达索引最大的位置,这个时候队列就满了不能再入队元素了吗?

    并不,如果同时也一直有元素出队,那么还是有空闲位置可以继续入队的,那要怎么表示呢?

    于是就出现了循环队列,这个类比时钟就很好理解
    在这里插入图片描述

    时钟的指针到达12之后就会归0,周而复始再次循环

    所以出入队指针的变化就可以表示成

    元素出队:(front+1)% maxSize
    元素入队:(rear+1)% maxSize

    那此时的队列的长度怎么获取呢?
    那就不是单纯的rear - front了,看图
    在这里插入图片描述
    队列长度计算公式:
    ( r e a r − f r o n t + m a x S i z e ) % m a x S i z e ( rear - front + maxSize)\% maxSize rearfront+maxSize%maxSize

    +maxSize:目的是防止rear - front < 0
    %maxSize:目的是防止当rear - front > 0时,又+ maxSize导致队列长度>maxSize

    展开全文
  • 顺序循环队列

    千次阅读 2019-01-08 08:49:52
    一 顺序表循环队列 1.1 顺序循环队列定义  队列是一种运算受限的先进先出线性表,仅允许在队尾插入(入队),在队首删除(出队)。新元素入队后成为新的队尾元素,元素出队后其后继元素就成为队首元素。  队列的...

    一  顺序表循环队列

    1.1 顺序循环队列定义

         队列是一种运算受限的先进先出线性表,仅允许在队尾插入(入队),在队首删除(出队)。新元素入队后成为新的队尾元素,元素出队后其后继元素就成为队首元素。

         队列的顺序存储结构使用一个数组和两个整型变量实现,其结构如下:

    1 struct Queue{
    2     ElemType elem[MaxSize];
    3     int head, tail;
    4 };

         即利用数组elem顺序存储队列中的所有元素,利用整型变量head和tail分别存储队首元素和队尾(或队尾下一个)元素的下标位置,分别称为队首指针和队尾指针。MaxSize指定顺序存储队列的最大长度,即队列中最多能够存储的元素个数。当队列的顺序存储空间静态分配时,MaxSize通常为宏定义;若动态分配时,还可为全局或局部变量。

         单向顺序队列存在“假溢出”问题,即多次入队和出队操作后,队首空余许多位置而队尾指针指向队列中最后一个元素位置,从而无法使新的数据元素入队。假溢出本质在于队首和队尾指针值不能由所定义数组下界值自动转为数组上界值,解决办法是将顺序队列构造成一个逻辑上首尾相连的循环表。当队列的第MaxSize-1个位置被占用后,只要队首还有可用空间,则把新的数据元素插入队列第0号位置。因此,顺序队列通常都采用顺序循环队列结构。

         下图所示为MaxSize=4的循环队列三种状态图:

     

         其中,为区分队空与队满,在入队时少用一个数据(图中下标为3的位置)。本文约定队首指针head指向队首元素,队尾指针tail指向队尾元素的下一个元素,以队尾指针加1等于队首指针判断队满,即:

    • 初始化:head = tail = 0;
    • 队列空:head == tail;
    • 队列满:(tail + 1) % MaxSize == head;
    • 元素数:num = (tail - head + MaxSize) % MaxSize

         %为取模运算符,循环队列利用数学上的取模运算将首尾巧妙相连。

         当约定head指向队首前一个元素,tail指向队尾元素时,元素数目仍满足上面的公式。当约定head指向队首元素,tail指向队尾元素时,元素数目为(tail - head + 1 + MaxSize) % MaxSize。

         此外,也可另设一个标志以区别队空和队满。该标志可为布尔型空满标志位,也可为队列中元素个数。

         通过队首元素位置和队列中元素个数,可计算出队尾元素所在位置。亦即,可用队列中元素个数代替队尾指针(或队首指针)。此时,队列满足:

    • 队列空:num == 0;
    • 队列满:num == MaxSize;
    • 队尾位置:tail = (head + num + MaxSize) % MaxSize

    代码实现如下:

    circularQueue.c

    /*初始化:head = tail = 0;
     * 队列空:head == tail;
     * 队列满:(tail + 1) % MaxSize == head;
     * 元素数:num = (tail - head + MaxSize) % MaxSize
     * */
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <unistd.h>
    #include <string.h>
    #include "circularQueue.h"
    
    //判断循环队列是否为空
    int IsQueEmpty(P_CIRCULAR_QUEUE cQue)
    {
        return cQue->cqHead == cQue->cqTail;
    }
    
    //判断循环队列是否满
    int IsQueFull(P_CIRCULAR_QUEUE cQue)
    { //为了区分队空的情况和队满的情况,使用+1来空出一个数据
        return (cQue->cqTail + 1) % cQue->maxSize == cQue->cqHead;
    }
    
    //获取循环队列的大小
    int getQueueSize(P_CIRCULAR_QUEUE cQue)
    {
       cQue->size = (cQue->cqTail - cQue->cqHead + cQue->maxSize) % cQue->maxSize;
       printf("cqTail[%d], cqHead[%d], size[%d]\n", cQue->cqTail, cQue->cqHead, cQue->size);
       return cQue->size;
    }
    
    //获取循环队列队首的位置
    int getQueueHead(P_CIRCULAR_QUEUE cQue)
    {
         return cQue->cqHead;
    }
    
    //获取循环队列队首元素
    int getQueueHeadData(P_CIRCULAR_QUEUE cQue)
    {
        return cQue->data[cQue->cqHead];
    }
    
    //获取循环队列队尾的位置
    int getQueueTail(P_CIRCULAR_QUEUE cQue)
    {
         return cQue->cqTail;
    }
    
    //获取循环队列队首元素
    int getQueueTailData(P_CIRCULAR_QUEUE cQue)
    {
        return cQue->data[cQue->cqTail];
    }
    
    //初始化循环队列
    void InitCircularQue(P_CIRCULAR_QUEUE cQue, int maxsize)
    {
        printf("cque size =%zu\n", sizeof(*cQue));
        cQue->data = (int*)malloc(sizeof(int)*maxsize);
        //memset(cQue, 0, sizeof(*cQue));
        cQue->cqTail = 0;
        cQue->cqHead = 0;
        cQue->size = 0;
        cQue->maxSize = maxsize;
        printf("cqHead[%d], cqTail[%d], maxSize[%d]\n", cQue->cqHead, cQue->cqTail, cQue->maxSize);
    }
    
    //向循环队列中插入元素
    void enterCircularQue(P_CIRCULAR_QUEUE cQue, int elem)
    {
        if(IsQueFull(cQue))
        {
            printf("Elem %d can't push to CircularQueue %p (Full)!\n", elem, cQue);
            return;
        }
        //cQue->data[cQue->cqTail] = elem;
        int *p = cQue->data;
        p[cQue->cqTail] = elem;
        cQue->cqTail = (cQue->cqTail + 1)%cQue->maxSize;
        printf("cqTail ==%d \n", cQue->cqTail);
    }
    
    //从循环队列中取数据
    int leaveCircularQue(P_CIRCULAR_QUEUE cQue)
    {
         if(IsQueEmpty(cQue))
         {
             printf("Queue %p is Empty! \n", cQue);
             return -1;
         }
    
         int elem = cQue->data[cQue->cqHead];
         cQue->cqHead = (cQue->cqHead + 1)%cQue->maxSize;
         printf("cqHead == %d \n", cQue->cqHead);
         return elem;
    }
    
    //显示队列中的所有元素
    void ShowQue(P_CIRCULAR_QUEUE cQue)
    {
         if(IsQueEmpty(cQue))
         {
             printf("Queue %p is Empty! \n", cQue);
             return ;
         }
    
         printf("CircularQueue Element: ");
         int elemIdx = cQue->cqHead;
         while((elemIdx % cQue->maxSize) != cQue->cqTail)
             printf("%d ", cQue->data[(elemIdx++) % cQue->maxSize]);
         printf("\n");
    }
    
    void delQue(P_CIRCULAR_QUEUE cQue)
    {
        cQue->cqTail = cQue->cqHead = 0;
        FREE(cQue->data);
    
    }
    View Code

    circularQueue.h

    #include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <unistd.h>
    
    #define FREE(p) \
        if (p != NULL) {\
            free(p);\
            p = NULL;\
        }
    
    typedef struct{
        //int data[QUEUE_SIZE]; //队列中的元素
        int *data;
        int cqHead;     //指向队首元素
        int cqTail;     //指向队尾元素
        int size;       //当前队列的大小
        int maxSize;    //可以容纳的最大大小
    }CIRCULAR_QUEUE, *P_CIRCULAR_QUEUE;
    
    int IsQueEmpty(P_CIRCULAR_QUEUE cQue);
    int IsQueFull(P_CIRCULAR_QUEUE cQue);
    int getQueueSize(P_CIRCULAR_QUEUE cQue);
    int getQueueHead(P_CIRCULAR_QUEUE cQue);
    int getQueueHeadData(P_CIRCULAR_QUEUE cQue);
    int getQueueTail(P_CIRCULAR_QUEUE cQue);
    int getQueueTailData(P_CIRCULAR_QUEUE cQue);
    
    //队列是先进先出FIFO
    void InitCircularQue(P_CIRCULAR_QUEUE cQue, int maxsize);
    void enterCircularQue(P_CIRCULAR_QUEUE cQue, int elem);
    int leaveCircularQue(P_CIRCULAR_QUEUE cQue);
    void ShowQue(P_CIRCULAR_QUEUE cQue);
    void delQue(P_CIRCULAR_QUEUE cQue);
    View Code

    main.c

    #include<stdio.h>
    #include<sys/types.h>
    #include<sys/stat.h>
    #include<fcntl.h>
    #include<unistd.h>
    #include<string.h>
    #include"circularQueue.h"
    
    #define QUEUE_SIZE 5 //队列中最大容纳QUEUE_SIZE-1个元素.
    
    int main()
    {
        CIRCULAR_QUEUE gcQue;
        InitCircularQue(&gcQue, QUEUE_SIZE);
        printf("Push circularQueue 1,2,3,4,5,6,7..\n");
        enterCircularQue(&gcQue, 1);
        enterCircularQue(&gcQue, 2);
        enterCircularQue(&gcQue, 3);
        enterCircularQue(&gcQue, 4);
        enterCircularQue(&gcQue, 5);
        enterCircularQue(&gcQue, 6);
        enterCircularQue(&gcQue, 7);
    
        printf("CircularQueue Elem Num %d\n", getQueueSize(&gcQue));
        ShowQue(&gcQue);
    
        printf("\nPop Queue...\n");
        printf("Pop %d \n", leaveCircularQue(&gcQue));
        ShowQue(&gcQue);
        printf("Pop %d \n", leaveCircularQue(&gcQue));
        ShowQue(&gcQue);
        printf("Pop %d \n", leaveCircularQue(&gcQue));
        ShowQue(&gcQue);
    
        delQue(&gcQue);
        printf("\n Push 6, 7 \n");
        enterCircularQue(&gcQue, 6);
        enterCircularQue(&gcQue, 7);
    
        printf("Pop %d \n", leaveCircularQue(&gcQue));
        ShowQue(&gcQue);
        printf("Pop %d \n", leaveCircularQue(&gcQue));
        ShowQue(&gcQue);
        printf("Pop %d \n", leaveCircularQue(&gcQue));
        ShowQue(&gcQue);
        return 0;
    }
    View Code

    测试结果如下:

    cque size =36
    Push circularQueue 1,2,3,4,5,6,7..
    cqTail ==1 
    cqTail ==2 
    cqTail ==3 
    cqTail ==4 
    Elem 5 can't push to CircularQueue 0x7fff579c15a0 (Full)!
    Elem 6 can't push to CircularQueue 0x7fff579c15a0 (Full)!
    Elem 7 can't push to CircularQueue 0x7fff579c15a0 (Full)!
    cqTail[4], cqHead[0], size[4]
    CircularQueue Elem Num 4
    CircularQueue Element: 1 2 3 4 
    
    Pop Queue...
    Pop 1 
    CircularQueue Element: 2 3 4 
    Pop 2 
    CircularQueue Element: 3 4 
    Pop 3 
    CircularQueue Element: 4 
    
     Push 6, 7 
    cqTail ==0 
    cqTail ==1 
    Pop 4 
    CircularQueue Element: 6 7 
    Pop 6 
    CircularQueue Element: 7 
    Pop 7 
    Queue 0x7fff579c15a0 is Empty! 

     

    展开全文
  • 循环队列的一些计算

    2019-04-18 09:25:00
    抄下面来的~~~ ... 循环队列的相关条件和公式: 1.队空条件:  rear==front ... (rear+1) %QueueSize==front,其中QueueSize为循环队列最大长度 3.计算队列长度:  (rear-front+QueueS...

    抄下面来的~~~

    https://www.cnblogs.com/shenckicc/p/7411734.html

     

    循环队列的相关条件和公式:

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

    转载于:https://www.cnblogs.com/tekikesyo/p/10727619.html

    展开全文
  • 任意输入队列长度和队列中的元素值,构造一个顺序循环队列,对其进行清空、插入新元素、返回队头元素以及删除队头元素操作。
  • 循环队列之循环队列长度和头尾指针关系

    万次阅读 多人点赞 2016-09-08 16:36:32
    1、为什么会引入循环队列?  对于顺序队列,头指针和尾指针开始时刻都指向数组的0下标元素。当加入新元素以后,尾指针向后移动,指向最后一个元素的下一个位置。 但是尾指针不能超过数组的最大范围。当有元素删除时...
  • 本文讲的是循环队列,首先我们必须明白下面几个问题 循环队列的基础知识 1.循环队列需要几个参数来确定 循环队列需要2个参数,front和rear 2.循环队列各个参数的含义 (1)队列初始化时,front和rear值都为零;...
  • 编程建立循环队列存储结构,对排队买票过程进行模拟。要求程序在控制台屏幕上显示字符菜单: 1. 排队——输入新到达的买票人姓名,加入买票队列中; 2. 售票——排队队列中最前面的人购票成功,显示信息并将其从队列...
  • 循环队列的基本操作实现

    千次阅读 2016-03-07 19:58:57
    front:指向队头元素的前一个单元 rear:指向队尾元素 maxSize:数组的最大长度 元素入队的时候,将队尾的指针加1,然后元素入队;...在循环队列的结构下,当front==rear时为空队列,当(rear+1)%
  • 数据结构习题——9循环队列

    千次阅读 2018-08-29 11:47:20
    假设将循环队列定义为:以域变量rear和length分别指示循环队列中队尾元素的位置和内含元素的个数。编写相应的入队列和出队列的程序,并判断循环队列是否队满(在出队列的算法中要返回队头...
  • 主要的功能:1)循环队列的初始化 2)求循环队列长度 3)循环队列的插入删除操作 4) 判断循环队列是否为空,是否已经满了 5)遍历循环队列 杨辉三角形
  • // 循环队列队列的顺序存储结构 #include<stdio.h> #include<malloc.h> #include<process.h> //exit 的头文件 #define OK 1 #define ERROR 0 #define MAXQSIZE 100// 最大队列长度 #define Status int #define N 10 ...
  • 什么是循环队列? 为充分利用向量空间,克服”假溢出“现象的方法:将向量空间想象为一个首尾相接的圆环,并称这种向量为循环向量。存储在其中的队列称为循环队列(Circular Queue)。 假象成如图: 但实际上存储...
  • 循环队列

    万次阅读 多人点赞 2018-10-31 18:25:58
    循环队列出现的原因 :顺序队列出队后 的空间不能再次利用,造成资源浪费。所以出现循环队列 这个代码是用tag标记的循环队列 思路:(rear+1)%m==front 则队列满,(front+1)%m == rear则队列空。队列开始为空,设...
  • 1.概述: C语言的队列(queue),是先进先出(FIFO, First...#define MAX_QSIZE 5 /* 最大队列长度+1 */ typedef struct { QElemType *base; /* 初始化的动态分配存储空间 */ int front; /* 头指针,若队列不空,指向
  • cout输出插入数据之后的队列长度"; cout(Q); cout输出删除的队首元素"; DeQueue(Q); cout输出删除之后的队列长度"; cout(Q); } void InitQuene(SqQuene &Q){ Q.base = (int*)malloc(MAXQSIZE * sizeof(int))...
  • #include #define MAXSIZE 10 #define OK 1 #define ERROR 0 ...//定义循环队列结构 typedef struct { QElemType *base; //初始化的动态分配存储空间 int front; //头指针,若队列不为空,指向队头元素 in
  • C语言实现顺序队列(循环队列)的常用操作,包括初始化顺序队,创建顺序队,入队,出队,计算队的长度,清空队列等等
  • 队列的顺序存储实现—循环队列

    千次阅读 2015-04-17 21:37:40
    队列(queue)是一种只允许在一端插入元素,而在另一端删除元素的线性表。它是一种先进先出(First In First Out,FIFO)的线性表。我们把允许插入的一端称为队尾,允许删除元素的一端称为队头。由于队列也是一种...
  • 循环队列的实现源码

    2014-08-21 17:17:11
    主要实现循环队列的初始化,入队,出队,求队的长度等算法
  • 循环队列长度为N。其队内有效长度为?(假设队头不存放数据) 对于循环队列 空间长度为N 是固定的 举个简单例子 空间 位置为 1,2,3,4,5,6, 空间长度为6 本体中 front 不存数据 如果front <= rear 则(rear-...
  • 练习题---循环队列

    千次阅读 2018-08-13 20:47:45
    经过一系列正常的入队与退队操作后, front=rear=15 ,此后又退出一个元素,则循环队列中的元素个数为(39或0,且产生下溢错误)。 【解析】循环队列是队列的一种顺序存储结构,用队尾指针 rear 指向队列中的队尾...
  • 1.任意输入队列长度和队列中的元素值,构造一个顺序循环队列,对其进行清空、插入新元素、返回队头元素以及删除队头元素操作。 2.约瑟夫环的实现:设有n个人围坐在圆桌周围,现从某个位置 i 上的人开始报数,数到 ...
  • 队列——链队列和循环队列

    千次阅读 2018-11-03 16:02:15
    队列 转载:https://www.cnblogs.com/muzijie/p/5655228.html 1 链队列的存储结构  将对头指针front指向链队列的头结点,队尾指针rear指向终端结点。 空队列时,头指针front和尾指针rear都指向头结点。 ...
  • 使用c++模板类方式实现循环队列,可存储任意类型对象长度数据,按照所需长度进行出栈获取数据,加入互斥锁可多线程使用。
  • C语言实现循环队列

    万次阅读 多人点赞 2020-06-24 15:58:46
    详解循环队列的巧妙之处

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 133,066
精华内容 53,226
关键字:

循环队列的最大长度