循环队列_循环队列c语言 - CSDN
循环队列 订阅
为充分利用向量空间,克服"假溢出"现象的方法是:将向量空间想象为一个首尾相接的圆环,并称这种向量为循环向量。存储在其中的队列称为循环队列(Circular Queue)。循环队列是把顺序队列首尾相连,把存储队列元素的表从逻辑上看成一个环,成为循环队列。 展开全文
为充分利用向量空间,克服"假溢出"现象的方法是:将向量空间想象为一个首尾相接的圆环,并称这种向量为循环向量。存储在其中的队列称为循环队列(Circular Queue)。循环队列是把顺序队列首尾相连,把存储队列元素的表从逻辑上看成一个环,成为循环队列。
信息
特    点
大小固定
实现方式
单链表
有关术语
队列
中文名
循环队列
外文名
Circular Queue
领    域
数据结构
循环队列简介
循环队列就是将队列存储空间的最后一个位置绕到第一个位置,形成逻辑上的环状空间,供队列循环使用。在循环队列结构中,当存储空间的最后一个位置已被使用而再要进入队运算时,只需要存储空间的第一个位置空闲,便可将元素加入到第一个位置,即将存储空间的第一个位置作为队尾。 [1]  循环队列可以更简单防止伪溢出的发生,但队列大小是固定的。在循环队列中,当队列为空时,有front=rear,而当所有队列空间全占满时,也有front=rear。为了区别这两种情况,规定循环队列最多只能有MaxSize-1个队列元素,当循环队列中只剩下一个空存储单元时,队列就已经满了。因此,队列判空的条件是front=rear,而队列判满的条件是front=(rear+1)%MaxSize。 [2] 
收起全文
精华内容
参与话题
  • 循环队列–C语言实现–数据结构

    万次阅读 多人点赞 2017-06-22 19:07:59
    循环队列–C语言实现–数据结构目录循环队列C语言实现数据结构目录 一 要求 二 循环队列循环队列的算法设计 1 建立循环队列 2 置空队列 3 入队 4 出队 5 打印队 四 程序 1 程序的结构 2 程序源码 五 程序测试 1 ...

    循环队列–C语言实现–数据结构


    目录


    (一) 要求

    假设以数组sequ[m]存放循环队列的元素,同时设变量rear和quelen 分别指示循环队列中队尾元素的位置和内含元素的个数。编写实现该循环队列的入队和出队操作的算法。提示:队空的条件:sq->quelen==0;队满的条件:sq->quelen==m。


    (二) 循环队列

    定义:为充分利用向量空间,克服”假溢出”现象的方法是:将向量空间想象为一个首尾相接的圆环,并称这种向量为循环向量。存储在其中的队列称为循环队列(Circular Queue)。这种循环队列可以以单链表的方式来在实际编程应用中来实现, 当然也可以利用顺序表来实现。顺序表就是我们熟悉的数组 eg. sun[]
    回顾:我们再来回顾一下关于顺序队列的重要知识点。队列通常与栈对应,栈是一种后进先出的单端(尾端)处理的数据结构;那么与之对应的队列是一种先进先出的双端(头尾两端)的数据结构。队列的特点就是在一段进行入队(存储数据)操作,在另一端进行出队(删除数据)操作。
    为什么设计循环队列:大家在处理队列的时候,会遇到如下情况。例如说:我们的队列空间能够容纳1000个元素。首先,格格入队1000个元素,队列上溢,此时为“真溢出”。那么现在我们进行出队操作,我们一直出队,一直出队, 知道1000个元素全部被删除,此时我们发现队列仍然处于“上溢”状态,why? 其实原因很简单,在非循环队列当中,无论我们的front指(偏移)到哪里,只要我们的rear指(偏移)向上阙,那么队列就是“满溢”的。这就造成了空间明明还被占据着,但是队列却已经无用武之地的窘境。对于空间有限的计算机来说,这无疑是一种浪费。也不是一个优秀的程序猿想要看到的。所以在这种情况下,循环队列诞生了。循环队列当中的“满溢”只有一种情况,那就是所有数据空降都被占领了。而不会存在非循环队列当中的“假溢出”现象。


    我们所常见的顺序循环队列通常有两种数据结构。

    结构一

    typedef struct
    {
        datatype sequ[m];
        //sequ[]为我们所建立的顺序表(sequence)
        int  front,rear;
        //front表示队列头的偏移量,rear表示队列的尾的偏移量
    }qu;//qu是队列(queue)的缩写

    这里写图片描述

    结构二

    typedef struct
    {
        datatype sequ[m];
        //sequ[]为我们所建立的顺序表(sequence)
        int  rear, quelen;
        //rear表示队列的尾的偏移量,quelen表示的是队列中元素的个数
    }qu;//qu是队列(queue)的缩写

    那通过观察这两种机构我们能够很容易的发现,数据结构并不是固定的。我们觉得那种算法比较更合理,我们觉得哪种数据结构方便我们设计算法,那么我们就建立哪种数据结构。在本文当中,我们采用第二种数据结构。显而易见的是,当我们采用第二种数据结构时,我们建立的一个队列指针(qu*sq)队空的条件:sq->quelen==0;队满的条件:sq->quelen==m。


    (三) 循环队列的算法设计


    在上面我们了解了循环队列的数据机构,但是仅仅学会了数据结构还远远不够。我们设计数据结构的目的是为了更好的存储数据,并利用数据。下面我们来看一看关于循环队列我们要掌握哪些最基本的算法(利用数据机构)。


    3.1 建立循环队列

    //建立队
    qu* creatqueue();//函数声明
    qu* creatqueue()//函数实现
    {
        qu *sq;
        sq=(qu*)malloc(sizeof(qu));
        return sq;  
    }

    3.2 置空队列

    //置空队
    void setnull(qu*);//函数声明
    void setnull(qu *sq)//函数实现
    {
        sq->rear = m - 1;
        sq->quelen = 0;
    }

    3.3 入队

    //入队
    void enqueue(qu*, datatype);//函数声明
    void enqueue(qu*sq, datatype x)//函数实现
    {
        if (sq->quelen == 5)
            printf("Errot! The queue will be overflow! \n");
        else if((sq->rear+1)==m)
        {
            sq->rear = (sq->rear + 1) % m;
            sq->sequ[sq->rear] = x;
            sq->quelen++;
            printf("过5入队成功!\n");
        }
        else
        {
            sq->rear++;
            sq->sequ[sq->rear] = x;
            sq->quelen++;
            printf("入队成功!\n");
        }
    }

    **算法流程图**


    3.4 出队

    //出队
    datatype *dequeue(qu*);//函数声明
    datatype *dequeue(qu*sq)//函数实现
    {
        datatype sun=0;
        if (sq->quelen == 0)
        {
            printf("Error! The queue will be under flow!\n");
            return 0;
        }
        else if ((sq->rear + 1) >= sq->quelen)
        {
            sq->quelen--;
            sun = sq->sequ[sq->rear - sq->quelen];
            return(&sun);
        }
        else    //  if(sq->rear < sq->quelen)
        {
            sq->quelen--;
            sun = sq->sequ[sq->rear - sq->quelen + m];
            return(&sun);
        }
    }
    

    **算法流程图**


    3.5 打印队

    //打印队
    void print(qu*);//函数声明
    void print(qu*sq)//函数定义
    {
        if (sq->quelen == 0)
            printf("Error! The queue is Null!\n");
        else if ((sq->rear + 1) >= sq->quelen)
        {
            int i = sq->rear + 1 - sq->quelen;
            for (i; i <= sq->rear; i++)
                printf("%d   ", sq->sequ[i]);
        }
        else
        {
            int t = sq->rear - sq->quelen + m +1;
            int time = 1;
            for (t; time <= (sq->quelen); time++)
            {
                printf("%d   ", sq->sequ[t]);
                t++;
                if (t == m)
                {
                    t = 0;
                    continue;
                }
                else
                {
                    continue;
                }
            }
        }
        printf("\n");
    }

    (四) 程序


    下面我们来设计一个程序测试我们的数据机构与算法


    4.1 程序的结构

    **程序结构**


    4.2 程序源码

    注意:该程序由Microsoft Visual Studio Enterprise 2015编译器进行调试。受制于编译器品牌及版本不同等不可抗因素造成的编译失败,请自行调整。

    #include<stdio.h>
    #include<stdlib.h>
    #include<malloc.h>
    #define m 5
    
    //循环队列的结构类型定义
    typedef int datatype;
    typedef struct
    {
        datatype sequ[m];
        int  rear, quelen;
    }qu;
    
    //函数声明
    qu* creatqueue();
    void setnull(qu*);
    void enqueue(qu*, datatype);
    datatype *dequeue(qu*);
    void print(qu*);
    
    //主函数
    void main()
    {
        qu *sq= creatqueue();
    
        datatype x, *p;
        int key;
    
        setnull(sq);
        do
        {
            printf("1.Enter Queue   2.Delete Queue   3.clc display   4.print queue   -1.Quit:");
            scanf_s("%d", &key);
            switch (key)
            {
            case 1:  printf("Enter the Data:"); scanf_s("%d", &x);
                enqueue(sq, x);  break;
            case 2:  p = dequeue(sq);
                if (p != NULL) printf("%d\n", *p);
                break;
            case 3:system("cls"); break;
            case 4:print(sq); break;
            case -1: exit(0);
            }
        } while (1);
    }
    
    //建立队
    qu* creatqueue()
    {
        qu *sq;
        sq=(qu*)malloc(sizeof(qu));
        return sq;  
    }
    //置空队
    void setnull(qu *sq)
    {
        sq->rear = m - 1;
        sq->quelen = 0;
    }
    
    //入队
    void enqueue(qu*sq, datatype x)
    {
        if (sq->quelen == 5)
            printf("Errot! The queue will be overflow! \n");
        else if((sq->rear+1)==m)
        {
            sq->rear = (sq->rear + 1) % m;
            sq->sequ[sq->rear] = x;
            sq->quelen++;
            printf("过5入队成功!\n");
        }
        else
        {
            sq->rear++;
            sq->sequ[sq->rear] = x;
            sq->quelen++;
            printf("入队成功!\n");
        }
    }
    
    
    //出队
    datatype *dequeue(qu*sq)
    {
        datatype sun=0;
        if (sq->quelen == 0)
        {
            printf("Error! The queue will be under flow!\n");
            return 0;
        }
        else if ((sq->rear + 1) >= sq->quelen)
        {
            sq->quelen--;
            sun = sq->sequ[sq->rear - sq->quelen];
            return(&sun);
        }
        else    //  if(sq->rear < sq->quelen)
        {
            sq->quelen--;
            sun = sq->sequ[sq->rear - sq->quelen + m];
            return(&sun);
        }
    }
    
    //打印队列
    void print(qu*sq)
    {
        if (sq->quelen == 0)
            printf("Error! The queue is Null!\n");
        else if ((sq->rear + 1) >= sq->quelen)
        {
            int i = sq->rear + 1 - sq->quelen;
            for (i; i <= sq->rear; i++)
                printf("%d   ", sq->sequ[i]);
        }
        else
        {
            int t = sq->rear - sq->quelen + m +1;
            int time = 1;
            for (t; time <= (sq->quelen); time++)
            {
                printf("%d   ", sq->sequ[t]);
                t++;
                if (t == m)
                {
                    t = 0;
                    continue;
                }
                else
                {
                    continue;
                }
            }
        }
        printf("\n");
    }
    
    

    (五) 程序测试


    5.1 入队列

    **入队列及上溢检测**


    5.2 出队列

    出队列及下溢检测


    5.3 打印队列

    前面已经用到了打印队列,所以格格不再赘述,大家由5.2&5.3可知打印队列是成功的。


    (六) 源程序及封装软件下载

    下载地址


    格格是一枚智能专业的本科在校生,很愿意和各位大佬交流。如果大家有愿意交朋友的,可以加格格的QQ:446019725,声明是CSDN即可。



    展开全文
  • 循环队列 基本概念

    万次阅读 多人点赞 2018-03-07 17:46:53
    循环队列是 队列的一种特殊形式。首先介绍队列,然后引申出循环队列。 队列又称为“先进先出”(FIFO)线性表 限定插入操作只能在队尾进行,而删除操作只能在队首进行 队列也可以采用顺序存储结构或链表结构来实现...

    循环队列是 队列的一种特殊形式。首先介绍队列,然后引申出循环队列。
    队列又称为“先进先出”(FIFO)线性表
    限定插入操作只能在队尾进行,而删除操作只能在队首进行
    队列也可以采用顺序存储结构或链表结构来实现,分别称为顺序队列和链队列

    队列的顺序表示—顺序队列

    用一组连续的存储单元依次存放从队首到队尾的元素,附设两个指针head和tail分别指向队首元素和队尾元素的位置,
    (有的地方用front 和 rear 表示)

    这里写图片描述
    当head = tail = 0时表示空队列

    这里写图片描述

    当插入新元素到队尾时,tail加1

    这里写图片描述

    当删除队首元素时,head加1,上图如果把C也删掉,那么就 head = tail 了

    tail 始终指向队列元素的下一个位置

    对应的操作:
    队空:head=tail
    求队长:tail - head
    入队:新元素按 tail 指示位置加入,再将队尾指针加1 ,即 tail = tail + 1
    出队:将head指示的元素取出,再将队头指针加1,即head = head + 1

    这里写图片描述

    下面引入循环队列

    这里写图片描述

    这里写图片描述

    入队,tail指针变化:
    tail= (tail+1)%maxsize

    这里写图片描述

    出队,head指针变化:
    head=( head +1)%maxsize

    删除数据C,队列为空

    这里写图片描述

    依次插入数据D,E,F,G,H,I,J,K
    队列满:head = tail

    这里写图片描述

    队满和队空时,均有head=tail
    因此,只凭head=tail 还无法区分是满还是空。

    如何判定队列满还是空?

    方法1:
    用一个计数变量来记载队列中的元素个数
    初始化队列时c=0;
    当入队时,计数变量+1( c=c+1 )
    当出队时,计数变量-1 (c=c-1)
    当计数变量=maxsize时,队满
    当计数变量=0时,队空

    方法2:
    牺牲一个元素空间,来区别队空或队满。
    入队前,先判Q.rear+1是否等于Q.front,
    若是则为队满。
    而当Q.front=Q.rear时,为队空。
    上图中:当数据J入队后,就认为队已满,
    而当数据K再要入队时,就拒绝入队。

    当队列已经满了,如果允许覆盖之前的数据:

    这里写图片描述

    队列已经满了之后,
    继续插入数据L,M,N,
    之前的数据D,E,F被覆盖
    此时,队列已经满了,
    最新的数据是:G,H,I,J,K,L,M,N

    在程序中,取队列的数据的时候,如果检测到 队列满了,
    此时,需要一次性取出队列中的数据,一次性取出数据的时候,不用管head指针,直接按照tail指针指向的位置开始取数据,直到循环取到tail-1位置停止。最终取出的数据的个数是 队列的长度 maxsize
    取出之后,可以对队列指针 head 和tail初始化为 0,需要将队列满整个标志设置为False.

    当应该用场景如下的时候:
    1. 数据是一条一条的进入队列的
    2. 队列中的数据是一次性读取的
    一次性读取出队列中的所有数据的方式:
    因为允许覆盖,有两种情况:
    当队列满了之后,
    需要根据tail,从tail所在位置的数据,绕一圈到tail-1位置所在的数据,都按照顺序取出来,这些数据是按照顺序,最新的数据。
    当队列没有满的时候,
    队列中所有的数据是 Head 到 tail之间的所有数据。

    参考代码:

    # -*- coding:utf-8 -*-
    
    class CircleQueue:
    
        def __init__(self,maxSize):
            self.head = 0
            self.tail = 0
            self.cnt  = 0
            self.list =[0]*maxSize
            self.size = maxSize
    
        def is_full(self):
            return self.cnt == self.size
    
        def is_empty(self):
            return 0 == self.cnt
    
        def initqueue(self):
    
            self.head = 0
            self.tail = 0
            self.cnt = 0
    
        def enqueue(self,element):
    
            if self.is_full():
                #print 'data: %s' % element, 'pos:%d' % self.tail, 'cnt :%d' % self.cnt
                self.list[self.tail] = element
                self.tail = (self.tail + 1) % self.size
    
            else:
                #print 'data: %s' % element, 'pos:%d' % self.tail, 'cnt :%d' % self.cnt
                self.list[self.tail] = element
                self.cnt += 1
                self.tail = (self.tail + 1) % self.size
    
        '''
        def dequeue(self):
    
            var_list = []
    
            if self.is_empty():
                raise Exception('queue is empty')
    
            if self.is_full():
                raise Exception('queue is empty')
    
    
            var_list.append(self.list[self.head])
    
            self.cnt -= 1
            self.head = (self.head + 1) % self.size
    
            return var_list
    
        '''
    
        def deClearAllQueue(self):
    
            var_list =[]
    
            if self.is_full():
    
                for i in range(self.tail,self.size):
                    var_list.append(self.list[i])
    
                for i in range(0,self.tail):
                    var_list.append(self.list[i])
    
            else:
                index = self.head
    
                while True:
                    if self.head == self.tail:
                        break
    
                    var_list.append(self.list[self.head])
                    self.head = (self.head +1)%self.size
    
    
            self.head = 0
            self.tail = 0
            self.cnt = 0
    
            return var_list
    
    
    
    
    queue = CircleQueue(7)
    
    
    for i in range(5):
        queue.enqueue(str(i))
    
    var = queue.deClearAllQueue()
    
    print var
    
    
    展开全文
  • 数据结构:循环队列(C语言实现)

    万次阅读 多人点赞 2014-03-07 19:15:14
    静态队列一般用数组来实现,但此时的队列必须是循环队列,否则会造成巨大的内存浪费;链式队列是用链表来实现队列的。这里讲的是循环队列,首先我们必须明白下面几个问题 一、循环队列的基础知识 1

    生活中有很多队列的影子,比如打饭排队,买火车票排队问题等,可以说与时间相关的问题,一般都会涉及到队列问题;从生活中,可以抽象出队列的概念,队列就是一个能够实现“先进先出”的存储结构。队列分为链式队列和静态队列;静态队列一般用数组来实现,但此时的队列必须是循环队列,否则会造成巨大的内存浪费;链式队列是用链表来实现队列的。这里讲的是循环队列,首先我们必须明白下面几个问题

    一、循环队列的基础知识

    1.循环队列需要几个参数来确定

    循环队列需要2个参数,front和rear

    2.循环队列各个参数的含义

    (1)队列初始化时,front和rear值都为零;

    (2)当队列不为空时,front指向队列的第一个元素,rear指向队列最后一个元素的下一个位置;

    (3)当队列为空时,front与rear的值相等,但不一定为零;

    3.循环队列入队的伪算法

    (1)把值存在rear所在的位置;

    (2)rear=(rear+1)%maxsize ,其中maxsize代表数组的长度;

    程序代码:

    bool Enqueue(PQUEUE Q, int val)
    {
    	if(FullQueue(Q))
    		return false;
    	else
    	{
    		Q->pBase[Q->rear]=val;
    		Q->rear=(Q->rear+1)%Q->maxsize;
    		return true;
    	}
    }
    


    4.循环队列出队的伪算法

    (1)先保存出队的值;

    (2)front=(front+1)%maxsize ,其中maxsize代表数组的长度;

    程序代码:

    bool Dequeue(PQUEUE Q, int *val)
    {
    	if(EmptyQueue(Q))
    	{
    		return false;
    	}
    	else
    	{
    		*val=Q->pBase[Q->front];
    		Q->front=(Q->front+1)%Q->maxsize;
    		return true;
    	}
    }


    5.如何判断循环队列是否为空

    if(front==rear)

    队列空;

    else

      队列不空;

    bool EmptyQueue(PQUEUE Q)
    {
    	if(Q->front==Q->rear)    //判断是否为空
    		return true;
    	else
    		return false;
    }


    6.如何判断循环队列是否为满


        这个问题比较复杂,假设数组的存数空间为7,此时已经存放1,a,5,7,22,90六个元素了,如果在往数组中添加一个元素,则rear=front;此时,队列满与队列空的判断条件front=rear相同,这样的话我们就不能判断队列到底是空还是满了;

    解决这个问题有两个办法:一是增加一个参数,用来记录数组中当前元素的个数;第二个办法是,少用一个存储空间,也就是数组的最后一个存数空间不用,当(rear+1)%maxsiz=front时,队列满;

    bool FullQueue(PQUEUE Q)
    {
    	if(Q->front==(Q->rear+1)%Q->maxsize)    //判断循环链表是否满,留一个预留空间不用
    		return true;
    	else
    		return false;
    }


    附录:

    queue.h文件代码:

    #ifndef __QUEUE_H_
    #define __QUEUE_H_
    typedef struct queue 
    {
    	int *pBase;
    	int front;    //指向队列第一个元素
    	int rear;    //指向队列最后一个元素的下一个元素
    	int maxsize; //循环队列的最大存储空间
    }QUEUE,*PQUEUE;
    
    void CreateQueue(PQUEUE Q,int maxsize);
    void TraverseQueue(PQUEUE Q);
    bool FullQueue(PQUEUE Q);
    bool EmptyQueue(PQUEUE Q);
    bool Enqueue(PQUEUE Q, int val);
    bool Dequeue(PQUEUE Q, int *val);
    #endif


    queue.c文件代码:

    #include<stdio.h>
    #include<stdlib.h>
    #include"malloc.h"
    #include"queue.h"
    /***********************************************
    Function: Create a empty stack;
    ************************************************/
    void CreateQueue(PQUEUE Q,int maxsize)
    {
    	Q->pBase=(int *)malloc(sizeof(int)*maxsize);
    	if(NULL==Q->pBase)
    	{
    		printf("Memory allocation failure");
    		exit(-1);        //退出程序
    	}
    	Q->front=0;         //初始化参数
    	Q->rear=0;
    	Q->maxsize=maxsize;
    }
    /***********************************************
    Function: Print the stack element;
    ************************************************/
    void TraverseQueue(PQUEUE Q)
    {
    	int i=Q->front;
    	printf("队中的元素是:\n");
    	while(i%Q->maxsize!=Q->rear)
    	{
    		printf("%d ",Q->pBase[i]);
    		i++;
    	}
    	printf("\n");
    }
    bool FullQueue(PQUEUE Q)
    {
    	if(Q->front==(Q->rear+1)%Q->maxsize)    //判断循环链表是否满,留一个预留空间不用
    		return true;
    	else
    		return false;
    }
    bool EmptyQueue(PQUEUE Q)
    {
    	if(Q->front==Q->rear)    //判断是否为空
    		return true;
    	else
    		return false;
    }
    bool Enqueue(PQUEUE Q, int val)
    {
    	if(FullQueue(Q))
    		return false;
    	else
    	{
    		Q->pBase[Q->rear]=val;
    		Q->rear=(Q->rear+1)%Q->maxsize;
    		return true;
    	}
    }
    
    bool Dequeue(PQUEUE Q, int *val)
    {
    	if(EmptyQueue(Q))
    	{
    		return false;
    	}
    	else
    	{
    		*val=Q->pBase[Q->front];
    		Q->front=(Q->front+1)%Q->maxsize;
    		return true;
    	}
    }
    


    展开全文
  • 循环队列

    2019-12-25 21:27:16
    顾名思义,循环队列是一种队列。 循环队列常用与服务器用户排队等待情况。 循环队列具有头指针f和尾指针r,头指针f指向队列中实际存在的第一个值,r指向队列中实际存在的最后一个值的下一个位置。 为什么要指向下一...

    顾名思义,循环队列是一种队列。

    循环队列常用于服务器用户排队等待情况。

    循环队列具有头指针f和尾指针r,头指针f指向队列中实际存在的第一个值,r指向队列中实际存在的最后一个值的下一个位置

    为什么要指向下一个位置?

    我们先假设尾指针r指向队列中实际存在的最后一个值。

    在这里插入图片描述
    f为首,r为尾
    push:r=(r+1)%n
    pop:f=(f+1)%n

    什么时候队列为空呢?删完了不就为空了,那么我们让f开始删除,每删除一个节点,f向后移动。
    循环删除后f的位置:f=(f+1)%n。(n为队列大小)

    在这里插入图片描述
    这种情况仅剩一个元素,f=r,再删除一个元素队列即为空。
    在这里插入图片描述
    此时队列为空,可以看出,为空时(r+1)%n=f

    那什么时候为满呢?

    我们用同样的思维可以得到满时的情况。在这里插入图片描述
    此时为满,(r+1)%n=f

    发现了吗,队满和对空竟然是一样的,那这样就没法判断什么时候是空还是满了。

    这次我们空出一块地方,把r指向实际存在的最后一个值的下一个位置。

    在这里插入图片描述
    这时,r指向实际存在的元素的下一个位置。

    那么聪明的你就发现了,这样做以后空和满的判断就不冲突了

    empty:r=f
    full:(r+1)%n=f

    另一种判断队列满还是空的方法:

    可以用一个变量index来计数,如果index=n泽满,index=0为空。此时r不需要指向后一个元素。

    展开全文
  • 循环队列的原理及例子

    千次阅读 2018-08-01 11:05:14
    对于嵌入式产品来说,会经常的进行数据收发操作。当因为短时间内有多帧数据而处理不过来时,可将数据暂存在缓冲区来做处理。队列和链表是作为缓冲...首先我们要说明的是循环队列仍然是基于数组实现的。但是为了形象...
  • C语言——循环队列

    千次阅读 2018-12-27 12:50:10
    循环队列 遵循先进先出(FIFO) 浪费一个空间,让循环队列更好的判断满/空,更好运用循环队列 黑色代表空时状态,红色代表满时状态 下面代码: #include &amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; ...
  • 循环队列实现

    千次阅读 2018-08-10 14:35:39
    假设是长度为5的数组,初始状态,空队列如所示,front与 rear指针均指向下标为0的位置。然后入队a1、a2、a3、a4, front指针依然指向下标为0位置,而rear指针指向下标为4的位置。   出队a1、a2,则front指针指向...
  • 现有一个循环队列,其队头指针为 front,队尾指针为 rear,循环队列的总长度为 N,问怎么判断循环队列满了? 正确答案: D front==rear front==rear+1 front==rear%n front==(rear+1)%n 当...
  • 1、为什么会引入循环队列?  对于顺序队列,头指针和尾指针开始时刻都指向数组的0下标元素。当加入新元素以后,尾指针向后移动,指向最后一个元素的下一个位置。 但是尾指针不能超过数组的最大范围。当有元素删除时...
  • 循环队列的元素个数计算公式

    万次阅读 2019-07-12 10:14:26
    因为循环对列,rear不一定比front大 如果rear<front结果是rear-front+maxsize 如果rear>front结果是rear-front 为了用一个表达式同时表达两者,用(rear-front+maxsize)%maxsize 假设maxsize=10 rear=1 ...
  • 循环队列元素个数

    万次阅读 2017-06-17 08:30:14
    1. 设有一个用数组Q[1..m]表示的环形队列,约定f为当前队头元素在数组中的位置,r为队尾元素的后一位置(按顺时针方向),若队列非空,则计算队列中元素个数的公式应为() A、 (m+r-f)mod m B、 r-f C...
  • 循环队列中判断队满与队空

    万次阅读 多人点赞 2017-08-14 17:57:34
    在引用循环队列前,我们需要了解队列是如何线性实现的。 简单地讲,便是当队列为空时,front = rear = 0,每当插入元素尾指针+1,删除元素是头指针-1。但是,我们会发现一个问题,如上面的第四个图,0,1,2三个...
  • 循环队列的相关计算公式

    千次阅读 2016-04-17 15:55:13
    · 设front为队首指针,rear为队尾指针,m为队列最大容量。 入队: rear = (rear + 1) % m出队: front = (front + 1) % m队空: front = rear队满: front = (rear + 1) % m当前队列中的元素数目: n = (rear ...
  • 循环队列满时,数组中还有一个空的单元。如图4-12-8所示,我们认为,队列已经满了,也就是说,我们不允许出现4-12-7的右图情况出现。   队列满的条件是: (rear+1)%QueueSize == front 通用的计算队列长度...
  • 循环队列: 队头指针:指向队首元素的前一个位置 队尾指针:指向队尾元素 循环栈: 队头指针:指向队首元素 队尾指针:指向队尾元素的后一个位置 ...
  • //循环队列的基本操作 #include #define MaxSize 50 typedef int ElemType; //定义循环队列结构体 typedef struct  { ElemType data[MaxSize]; int front,rear; }SqQueue; //初始化 void ...
  • 循环队列 代码实现(FIFO)

    万次阅读 2017-05-09 22:28:31
    存储在其中的队列称为循环队列(Circular Queue)。这种循环队列可以以单链表的方式来在实际编程应用中来实现。  循环队列中,由于入队时尾指针向前追赶头指针;出队时头指针向前追赶尾指针,造成队空和队满时头尾...
  • 同样,队列作为一种特殊的线性表,也同样存在两种存储方式。 那就是顺序队列、链式队列两种 这里主要介绍顺序队列,链式队列我在上一篇博客中详细介绍了(因为用的比较多)。想看链式队列的话大家可以参考 ...
  • 静态队列

    万次阅读 2020-05-05 13:10:24
    静态队列通常都必须是循环队列 循环队列的讲解: 1.静态队列为什么必须是循环队列 数组表示的问题   对于队列最好的方法是使用链表实现,因为对于数组来说,队列可能会出现下面这种情况: 如图所示,不可以...
  • 循环队列队满和队空判定

    万次阅读 2018-06-18 21:47:48
    顺序存储结构的循环队列假设循环队列的队尾指针是rear,队头是front,其中QueueSize为循环队列的最大长度。(1) 入队时队尾指针前进1:(rear+1)%QueueSize(2) 出队时队头指针前进1:(front+1)%QueueSize例1, 例2(3)...
1 2 3 4 5 ... 20
收藏数 345,990
精华内容 138,396
关键字:

循环队列