精华内容
下载资源
问答
  • 题目: 若希望循环队列中的元素都能得到利用,则需设置一个标志域tag... tag ==0,队空; front ==rear && tag ==1,队满; 初始化: #define MaxSize 50; typedef struct{ ElemType data[MaxSize]; int front

    题目:
    若希望循环队列中的元素都能得到利用,则需设置一个标志域tag,并以tag的值为0或1来区分队头指针front和队尾指针rear相同时队列状态是空还是满。试编写与此结构相对应的入队和出队算法。

    front ==rear && tag ==0,队空;
    front ==rear && tag ==1,队满;

    初始化:

    #define MaxSize 50;
    typedef struct{
        ElemType data[MaxSize];
        int front,rear,tag;
    }SqQueue;
    

    入队:

    bool EnQueue(SqQueue &Q,ElemType x){
        if(Q.tag == 1 && Q.front == Q.rear) return false; //队满不允许插入元素;
        
        //初始时,front=rear=-1,增加元素时,rear先加1再赋值;
        Q.rear = (Q.rear +1)%MaxSize; //需要插入元素的位置;
        Q.data[Q.rear] = x;
    	//如果队满;
    	Q.tag =1;
        return true;
    }
    

    出队:

    bool DeQueue(SqQueue &Q,ElemType &x){
        if(Q.tag ==0 && Q.front ==Q.rear) return false; //队空,不再删除元素;
        
        //假设front初始时为-1,则删除元素时,front先加1再删除元素;
        Q.front = (Q.front+1)%MaxSize;
        x = Q.data[Q.front];
        //如果队空;
        Q.tag =0;
        return true;
    }
    
    展开全文
  • 首先我们定义一个具有基本操作方法的Queue类,在这个类中我们设置了一个bool型的变量tag,通过判断tag的值来判断队列是否为、是否为。具体是:rear==front&&!tag为,rear==front&...

    我们首先需要了解的是:循环队列的实现有三种方式

    1. 浪费一个元素的存储空间:front指向队首的实际位置,rear指向实际位置的下一个位置,front==rear时为空,(rear+1) % m == front时为满
    2. 使用标记tag,front指向队首实际位置,rear指向队尾实际位置的下一个位置,入队时tag=1,出队时tag=0,当front == rear && tag == 0时队空,当front == rear && tag == 1时队满
    3. 使用front,rear, length作为判断队空队满的标志,这样就不用浪费一个元素的存储空间了,和tag的作用是一样的,front指向队首实际位置,rear指向队尾实际位置

    这里我只实现一下第二种:

    首先我们定义一个具有基本操作方法的Queue类,在这个类中我们设置了一个bool型的变量tag,通过判断tag的值来判断队列是否为空、是否为满。具体是:rear==front&&!tag为空,rear==front&&tag为满。
    queue.h如下:

    #ifndef QUEUE_H
    #define QUEUE_H
    
    #include<iostream>
    using namespace std;
    
    template<class T>
    class Queue {
    private:
        int maxSize;                           //存放队列数组的大小
        int front;                             //表示队头所在位置的下标
        int rear;                              //表示队尾所在位置的下标
        int *queue;                            //存放类型为T的队列元素的数组
        bool tag;                              //0为空,1为不空
    public:
        Queue(int size);
        ~Queue() {
        delete[] queue;
        }
        void Clear();                          //清空队列
        bool EnQueue(const T item);            //item入队,插入队尾
        bool DeQueue(T & item);                //返回队头元素,并删除该元素
        bool GetFront(T & item);               //返回队头元素但不删除
        void disPlay();                        //输出队列
    };
    
    template<class T>
    Queue<T>::Queue(int size) {
        maxSize = size;
        tag = 0;
        queue = new T[maxSize];
        front = rear = 0;
    }
    
    template<class T>
    void Queue<T>::Clear() {
        front = rear;
        tag = 0;
    }
    
    template<class T>
    bool Queue<T>::EnQueue(const T item) {
        if (rear==front&&tag) {
            cout << "队列已满,溢出!" << endl;
            return false;
        }
        queue[rear] = item;
        rear = (rear + 1) % maxSize;
        tag = 1;
        return true;
    }
    
    template<class T>
    bool Queue<T>::DeQueue(T & item) {
        if (rear==front&&!tag) {
            cout << "队列为空,溢出!" << endl;
            return false;
        }
        item = queue[front];
        front = (front + 1) % maxSize;
        tag = 0;
        return true;
    }
    
    template<class T>
    bool Queue<T>::GetFront(T & item) {
        if (rear==front&&!tag) {
            cout << "队列为空,溢出!" << endl;
            return false;
        }
        item = queue[front];
        return true;
    }
    
    template<class T>
    void Queue<T>::disPlay() {
        if (rear==front&&!tag) {
            cout << "队列为空!" << endl;
            return;
        }
        if (front == rear&&tag!=0) {
            for (int i = 0; i < maxSize; i++) {
                cout << queue[i] << " ";
            }
        }
        for (int i = front;; i = (i + 1) % maxSize) {
            if (i == rear)
                break;
            cout << queue[i] << " ";
        }
        cout << endl;
    }
    #endif // !QUEUE_H
    
    展开全文
  • ☝☝☝软件工程考研独家平台撰稿| 康康哥编辑| 丽丽姐本文由懂计算机、软件工程的博士师哥原创双日练:NO.20200922循环队列放在一维...下列判断队空队满的条件中,正确的是 ( )。A.队空:end1 == end2;队满:...
    ☝☝☝ 软件工程考研独家平台

    撰稿 | 康康哥

    编辑 | 丽丽姐

    本文由懂计算机、软件工程的博士师哥原创

    55d95f65330ccfa487848a6893743a85.png

    双日练:NO.20200922

    ee46813d753599cddd1e1767f46acdf2.png

    循环队列放在一维数组A[0…M-1]中,end1指向队头元素,end2指向队尾元素的后一个位置。假设队列两端均可进行入队和出队操作,队列中最多能容纳M-1个元素。初始时为空。下列判断队空和队满的条件中,正确的是 ( )。

    A.队空:end1 == end2;队满:end1 == (end2+1)mod M

    B.队空:end1 == end2;队满:end2 == (end1+1)mod (M-1)

    C.队空:end2 == (end1+1)mod M;队满:end1 == (end2+1)mod M

    D.  队空:end1 == (end2+1)mod M;队满:end2 == (end1+1)mod (M-1)

    本题考查:循环队列判断队空队满。

    循环队列判断队满:Q.front== (Q.rear + 1) % MAXSIZE

    判断队空: Q.front== Q.rear

    将end1替换front,end2替换rear,因此得:

    队空:end1 == end2

    队满:end1 == (end2+1)modM

    因此选A。

    63c65ad28fee4967a0b8e24dbdb7eb3c.png软工博士带你飞
    考软工 · 看CS优化狮2f18a5255a8aa02346513f4933ada54d.pngb4ad96059d20a2eb9c76d62a5d2f1b85.png
    展开全文
  • 循环队列判断队满队空的条件

    千次阅读 2019-10-15 15:34:21
    标循环队列判断队满队空的条件 队满:front=(rear+1)%size ; 队空:front = rear&&

    标循环队列判断队满和队空的条件

    队满:front=(rear+1)%size ;
    队空:front = rear&&
    在这里插入图片描述
    图片上的信息来自王红梅教授版数据结构第二版

    展开全文
  • 循环队列中判断队满队空

    万次阅读 多人点赞 2016-04-02 11:16:38
    在引用循环队列前,我们需要了解队列是如何线性实现的。 简单地讲,便是当队列为空时,front = rear = 0,每当插入元素尾...我们可以发现,当循环队列属于上图的d1情况时,是无法判断当前状态是队空还是队满。为了
  • 为了方便对于循环队列进行队空队满判断,牺牲一个存储单元。记rear、head分别为队尾队头指针则: 队满:(rear+1)%maxsize=head 队空:rear=head 插入元素后,rear=(rear+1)%maxsize 删除元素后,head=(head+1...
  • 因此只凭等式front=rear无法判断队空还是队满。 有两种方法处理上述问题: (1)另设一个标志位以区别队列是空还是满。 (2)少用一个元素空间,约定以“队列头指针front在队尾指针rear的下一个位置上”作为队列“满...
  • 如何判断循环队列为队空or队满

    千次阅读 2020-02-16 13:18:35
    什么是循环队列 循环队列就是将队列存储空间的最后一个位置绕到第一个位置,首尾相连形成逻辑上的环状空间,供队列循环使用。 循环队列可以更简单防止假溢出的发生,但队列大小是固定...如何判断循环队列为队空or...
  • 在引用循环队列前,我们需要了解队列是如何线性实现的。 简单地讲,便是当队列为空时,front = rear = 0,每当插入元素尾指针+1,...我们可以发现,当循环队列属于上图的d1情况时,是无法判断当前状态是队空还是队满
  • 循环队列设置tag标志域判断队满队空 算法思想: tag等于0的情况下,若因删除导致Q.Rear==Q.Front则为队空 tag等于1的情况下,若因插入导致Q.Rear==Q.Front则为队满 核心代码: //tag等于0的情况下,若因删除...
  • 队列的性质队列满足的基本性质为先进先出,后进后出。eg:生活中类似于排队打饭一样,先排队的先打饭。...图解:如上图可以得出:判断队列的方法就是队尾加1除以队长跟头位置是否相等。即(S->rear+1)%Siz...
  • 循环队列队列有着先入先出的特性。但是对于队列如果删除头...对照着图很容易理解:对于原来队列里的操作自然有不同的地方:判断满:循环队列的不再是rear=front 而是改成(rear-front+maxn)%maxn。入队操作: dat...
  • 由于指针可以循环了,怎么判断队列为的情况呢?很自然的,我们想到一开始为的情况,就是队首指针front和队尾指针rear都重叠在起始位置,判断条件也就是front == rear成立的时候为。 我们来看看队列的...
  • (二) 队列定义和栈相似,队列也是一种特殊的线性表...队列的基本操作和栈相似,对于队列,插入数据只能在队尾进行,删除数据只能在头进行,在队列中插入数据我们叫入队enqueue,删除队列中的数据我们叫出deque...
  • }运行结果:数字个数是0判断空的结果是1判断满的结果是0数字个数是3判断空的结果是0判断满的结果是0最前面的数字是1010 20数字个数是1判断空的结果是0判断满的结果是0数字个数是3判断空的结果是0判断满的结果是030 ...
  • 循环队列: 结构: typedef struct { ElemType *data; //数据域 int front; //队头 int rear;...判队空 判空 判断等式是否成立: Q.front == Q.rear 判队满队满 因为循环队列会空出来一个位置...
  • (纠错:上图中出队列应该是:x=sq[front++])简单地讲,便是当队列为时,front = rear = 0,每当插入元素尾指针+1,删除元素是头指针-1。但是,我们会发现一个问题,如上面的第四个图,0,1,2三个空间并没有使用...
  • 循环队列实现(通过设置标志位tag位判断空队满队)
  • #include #include #define MAX 10 enum s { QUEUE_EMPTY, QUEUE_NOEMPTY, QUEUE_FULL, QUEUE_NOFULL, IN_NO, IN_OK, OUT_NO, OUT_OK }; struct node { int front; int rear; ...void
  • 本周的作业要求: 1.给出循环队列的存储结构定义。 2.完成循环队列的基本操作函数。... 4) 采用下面两种方法实现对满和队空判断操作: 方法一:修改队满条件,浪费一个元素空间,队满时数组中只有一个...
  • front表示队头指针(指向队列内首元素) rear表示队尾指针(指向队列内尾元素的下一个位置) m表示队列的容量 ...队空:front=rear 队满:front=(rear+1)%m 队列内元素个数:(rear - front + m) % m ...
  • 循环队列队队满两个状态的判断算法分析 线性表是数据结构中比较重要的一种逻辑结构,插入删除操作是线性表的基本操作, 当进行这些操作时,不仅需要考虑插入、删除的位置是否合法性, 仍然需要考虑‘满’与...
  • 环形队列判断队满

    2020-12-28 17:47:49
    在引用循环队列前,我们需要了解队列是如何...我们可以发现,当循环队列属于上图的d1情况时,是无法判断当前状态是队空还是队满。为了达到判断队列状态的目的,可以通过牺牲一个存储空间来实现。 如上图d2所示, 队头

空空如也

空空如也

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

判断队空队满