精华内容
下载资源
问答
  • 2012-05-30 17:18:30

    此问题 有两种处理方法:

     (1) 另设一个标志符 区分队列空还是满;

    (2)少用一个元素空间,约定队头在队尾指针的下一位置时作为队满的标志; 


    本人知实验了第二种:若SqQueue队列初始化为有size=10,则此队列实际只有9个元素;


    另外:循环队列 队头有元素  rear 没指向任何元素    ;而链队列 队头无元素 ,队尾有元素;


    更多相关内容
  • 循环队列front==rear

    万次阅读 2019-10-27 17:11:58
    循环队列队和队的条件都是front==rear,怎么区分这两者之间的差别? 方案一: 分析:该循环数列包含data数组、队头指针front和队中的元素个数count字段。初始时front和count均置为0.队的条件为count0;队的...

    循环队列队满和队空的条件都是front==rear,怎么区分这两者之间的差别?

    方案一:

    分析:该循环数列包含data数组、队头指针front和队中的元素个数count字段。初始时front和count均置为0.队空的条件为count0;队满的条件为countmaxsize。代码如下:

    class SqQueueClass2
    {
      const  int  MaxSize=5;   
    private  string[]  data;   //存放队中的元素
    private  int  front;       //队头指针
    private  int  count;      //队列中元素的个数
    public  SqQueueClass2()  //构造函数,用于队列初始化
    {
      data=new  string  [MaxSize];
      front=0;
      count=0;
    }
    }
    //-----------------基本运算算法-----------------
    //判断队列是否为空-
    public  bool  QueueEmpty()
    {
      return  (count==0);
    }
    //进队列算法
    public  bool  enQueue(string e)
    {
      int  rear;
      rear=(front+count)%MaxSize;
      if(count==MaxSize)      //队满
    Return false;
      rear=(rear+1)%MaxSize;
      data[rear]=e;
      count++;
      return  true;
    }
    //出队列算法
    public  bool  deQueue()
    {
      if (count==0)
    return false;
    front=(front+1)%MaxSize;
    e=data[front];
      count--;
      return true;
    }
    //求队列中的元素个数
    public int GetCount()
    {
     return count;
    }
    

    方案二:

    用front和rear分别作为队头和队尾指针,另外用一个标识tag标识队列可能为空(0)或可能满(1),frontrear可以作为队空或队满的条件。Tag初始值置为0,每当入队成功,tag=1,每当出队成功,tag=0。当frontrear&&tag1时,表示在入队操作后front=rear,此时队满,同理,frontrear&&tag==0时则表示队空。
    代码如下:

    namespace ConsoleApplication
    {
       class sqQueueClass
       {
            const int MaxSize = 100;
            public string[] data;
            public int front, rear;
            public int tag = 0;
            public sqQueueClass()
            {
                data = new string[MaxSize];
                front = rear = -1;
             }
    //判断是否为空
             public bool QueueEmpty()
             {
                return (front == rear && tag == 0);
              }
    //进队算法
              public bool enQueue(string e)
              {
                if (front == rear && tag == 1)
                    return false;
                rear = (rear + 1) % MaxSize;
                data[rear] = e;
                tag = 1;
                return true;
              }
    //出队算法
              public bool deQueue(ref string e)
              {
                if (front == rear && tag == 0)
                    return false;
                front = (front + 1) % MaxSize;
                e = data[front];
                tag = 0;
                return true;
              }
        }
    }
    

    比较:

    方案一判断条件较为简单,但浪费了一个存储空间,且可用一个count变量直接得知队列中元素的个数;方案二能够充分利用存储空间,但在进行出队入队操作时,每次都需要对tag进行重新定义,除此之外,方案二判断条件也较为复杂。

    总结:

    由于非循环队列的假溢出现象以及为了能够充分地使用数组的存储空间,把数组的前端和后端连接起来形成循环队列。循环队列在实现入队出队操作时,应注意算法实现顺序,入队时先判断是不是队满,出队时先判断是不是队空,然后再进行相应的入队出队操作。

    展开全文
  • rear指向队尾元素,队时不应该是(rear+1+maxSize)%maxSize==front吗?为什么说队front==rear呢?这样的话不是可以使用所有的空间了吗?为什么还要让rear指向队尾元素的下一个位置,少用一个空间呢?
  • 在循环队列中设置一个标志flag,当front=rear且flag=0时为队,当front=rear且flag=1时候队,请编写相应的入队和出队算法(假设队头指针front指向对头元素的前一个位置,队尾指针rear指向队尾元素)

    1.在循环队列中设置一个标志flag,当front=rear且flag=0时为队空,当front=rear且flag=1时候队满,请编写相应的入队和出队算法(假设队头指针front指向对头元素的前一个位置,队尾指针rear指向队尾元素)

    2.代码展示(复制可直接运行)

    public class Y2019T9 { //队列 先进先出
    	static int SIZE=3;
    	public static int deQueue(CirQueue c) {//出队
    		if(c.front==c.rear&&c.flag==0){
    			System.out.println("队空");
    			return 0;
    		}
    		System.out.println("出队元素"+c.datarQueueSize[c.front]);
    		c.front=(c.front+1)%SIZE;
    		c.flag=0;
    		return 1;
    	}
    	public static void EnQueue(int x,CirQueue c){//入队
    		if(c.rear%SIZE==c.front&&c.flag==1){
    			System.out.println("队满");
    		}else{
    			System.out.println("入队元素"+x);
    			c.datarQueueSize[c.rear]=x;
    			c.rear=(c.rear+1)%SIZE;
    			System.out.println("============");
    			c.flag=1;
    		}
    	}
    	public static void main(String[] args){
    		CirQueue c=new CirQueue();
    		c.front=0;
    		c.rear=c.front;
    		c.flag=0;
    		EnQueue(3, c);
    		deQueue(c);
    		deQueue(c);
    		EnQueue(3, c);
    		EnQueue(4, c);
    		EnQueue(5, c);
    		EnQueue(5, c);
    		deQueue(c);
    		deQueue(c);
    		EnQueue(5, c);
    		deQueue(c);
    		deQueue(c);
    		deQueue(c);
    		deQueue(c);
    	}
    }
    class CirQueue{
    	int datarQueueSize[]=new int[3];
    	int front,rear;
    	int flag;
    }

    展开全文
  • 设计一个环形队列,用frontrear分别作为队头和队尾指针,另外用一个tag表示队列(0)还是(1),这样就可以用front==rear作为堆的条件。要求设计队列相关基本运算算法。 数据结构上机作业 第二章15题 张...
  • #include <iostream> #include <stdio.h> #include <stdlib.h> #define maxsize 100 using namespace std;... int front,rear; int tag; }squeue; int ...
    #include <iostream>
    #include <stdio.h>
    #include <stdlib.h>
    #define maxsize 100
    using namespace std;
    
    typedef struct {
      int data[maxsize];
      int front,rear;
      int tag;
    }squeue;
    int desqueue(squeue &sq,int &x)
    {
        if(sq.front==sq.rear&&sq.tag==0) return 0;
        else
        {
            x=sq.data[sq.front];
            sq.front=(sq.front+1)%maxsize;
            if(sq.rear==sq.front) sq.tag=0;
            return 1;
        }
    }
    int ensqueue(squeue &sq,int x)
    {
        if(sq.front==sq.rear&&sq.tag==1) return 0;
        else
        {
            sq.data[sq.rear]=x;
            sq.rear=(sq.rear+1)%maxsize;
            if(sq.rear==sq.front) sq.tag=1;
            return 1;
        }
    }
    int main()
    {
        squeue sq;
        sq.front=0;
        sq.rear=0;
        sq.tag=0;
        int x=0;
        ensqueue(sq,3);
        desqueue(sq,x);
        printf("%d",x);
        return 0;
    }
    

     

    展开全文
  • 计算机二级公共基础选择题31-40

    千次阅读 2021-07-13 01:03:17
    经过一系列正常的入队与退队操作后,front=rear=15,此后又退出一个元素,则循环队列中的元素个数为A) 14B)15C)40D)39,或0且产生下溢错误D【解析】当front=rear=15时可知队列空或者队列满,此后又退出一个元素,...
  • 设计一个循环队列,用frontrear分别作为队头和队尾指针,另外用一个标志tag表示队列空还是不空,约定当tag为0时队空,当tag为1时队不空,这样就可以用front==rear作为队的条件要求,设计队列的结构和相关基本...
  • 队列详解

    2020-07-01 17:42:01
    队列详解 定义 在这里插入代码片队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表...判断队列是否为满队列,若为满队列则输出提示信息,否则执行2; rear ++ ; arr[rear] = temp
  • 入队操作 int Enqueue(SqQueue &Q,ElemType x){ if(Q.front==Q.rear&&Q.tag==1){ return 0;//队 ... Q.data[Q.rear]=x;... Q.rear=(rear+1)%maxsize; Q.tag=1; return 1; } 出...
  • 办法一:设置一个标志flag,当front == rear 且 flag = 0 为空队列front == rear 且 flag = 1 为满队列(烦琐) 办法二: 满队列时,数组中还存在一个空闲单元(简单) 满队列的条件是(rear + 1)%QueueSize ...
  • 设以数组se[m]存放循环队列的元素,同时设变量rearfront分别作为队头队尾指针,且队头指针指向队头前一个位置,写出这样设计的循环队列入队和出队算法。
  • 在引用循环队列前,我们需要了解队列是如何线性实现的。 简单地讲,便是当队列为空时,...循环队列原理图: 我们可以发现,当循环队列属于上图的d1情况时,是无法判断当前状态是队空还是。为了达到判断队列状...
  • 判断队列为或者为

    千次阅读 2020-08-11 19:15:20
    因此只凭等式front=rear无法判断空还是。 有两种方法处理上述问题: (1)另设一个标志位以区别队列空还是满。 (2)少用一个元素空间,约定以“队列头指针front在队尾指针rear的下一个位置上”作为队列...
  • 循环队列判断队列空的3种方法

    万次阅读 多人点赞 2020-02-14 19:32:18
    队列满时条件为:rear+1 == front      上述方式对于上述图是适用的,但如果出现了有下标标识,上述判断条件就不适用了。比如下图有下标了,当队列满时,显然条件就不能判断了,就要用到另一种判断。   第二...
  • 队列 队列的顺序存储结构 队列的链式存储结构 入队操作 出队操作 队列 队列的顺序存储结构 队列队列,顾名思义就是平常我们排队的时候的一种结构,下面JV带你详细看看它的定义。 队列(queue)是只允许在...
  • 队列为时:rear= =front 队列满时:(rear+1)%maxSize= =front 不少一个存储位置时:加一个标志flag或者计数的count 入队时flag=true 出队时flag=false 队rear= =front&flag 队rear= =front&!...
  • ① 初始时,front=rear=0,front代表指向队列的第一个元素(即arr[front]是队列的第一个元素),rear代表指向队列的最后一个元素的后一个元素,当front=rear时表示队列,注意为时不一定front=rear=0。当rear=...
  • 时: Q.front == Q.rear;队时: Q.front == (Q.rear + 1) % MAXSIZE;front指向队首元素,rear指向队尾元素的下一个元素。maxsize是队列长度。扩展资料:实现的代码:#include #include #define MAXSIZE 100 //...
  • 关于计算机二级考试内容

    千次阅读 2021-07-13 01:02:02
    为了让大家更好的备考计算机二级考试,练习往年真题很...循环队列的存储空间为Q(1:50),初始状态为front=rear=50.经过一系列正常的入队与退队操作后,front=rear=25,此后又插入一个元素,则循环队列中的元素个数为()。
  • 判断队列是否为3.入队(尾插法)4.出队(头部删除)完整代码 一、链队列的特点 队列的链式表示称为链队列。它是一个同时带有队头指针和队尾指针的单链表,其中队头指针指队头,队尾指针指队尾。 二、代码实现 ...
  • 我们这里一共三个方法,通过是否舍弃空间来实现队列空满判断队列的数据结构 const int MaxSize=10; typedef struct { int data[MaxSize]; int front,rear; }Queue; front指向第一个元素。 rear指向下一个...
  • 数据结构 主讲人章万静 是 否 开始 结束 front==rear 定义变量 非空队列 空队列 循环队列判断队列空 获取头指针位置front 获取尾指针位置rear 循环队列判断队列空 判断循环队列是否为很重要在出队列操作前必须判断...
  • 问题描述:循环队列为条件是 rearfront 。如果进队元素的速度快于出队元素的速度,队尾指针很快就赶上了队首指针,此时可以看出循环...循环队列的队头指针和队尾指针初始化时都置0,队条件:(rear+1)%MaxSiz...
  • 循环队列

    2021-07-15 02:42:30
    循环队列是把顺序队列首尾相连,把存储队列元素的表从逻辑上看成一个环,成为循环队列。中文名循环队列外文名Circular Queue领域实现方式有关术语特点大小固定循环队列简介编辑语音循环队列就是将队列存储空间的最后...
  • 如何判断循环队列为队or队

    千次阅读 多人点赞 2020-02-16 13:18:35
    什么是循环队列 循环队列就是将队列存储空间的最后一个位置绕到第一个位置,首尾相连形成逻辑上的环状空间,供队列循环使用。 循环队列可以更简单防止假溢出的发生,但队列大小是固定...如何判断循环队列为队or...
  • 因此,我们无法通过front=rear判断队列还是”。 注:先进入的为‘头’,后进入的为‘尾’。 解决此问题的方法至少有三种: 其一是另设一个布尔变量以匹别队列; 其二是少用一个元素的空间,...
  • front表示队头指针(指向队列内首元素) rear表示队尾指针(指向队列内尾元素的下一个位置) m表示队列的容量 ...队front=rearfront=(rear+1)%m 队列内元素个数:(rear - front + m) % m ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 52,213
精华内容 20,885
关键字:

如何判断队列是空还是满,front=rear