精华内容
下载资源
问答
  • 判断循环队列还是

    千次阅读 2013-10-28 00:06:20
    判断一个循环队列还是的方法: 方法一:设置一个标志tag,当每一次入队的时候,令tag = 1;当出队的时候,tag = 0;所以,如果在tag = 1后,Q.front = Q.rare,则说明是因为插队而引起的,所以是因为队列了;...

    判断一个循环队列是满还是空的方法:

    方法一:设置一个标志tag,当每一次入队的时候,令tag = 1;当出队的时候,tag = 0;所以,如果在tag = 1后,Q.front = Q.rare,则说明是因为插队而引起的,所以是因为队列满了;反之,tag = 0时,Q.front = Q.rare,则说明是因为出队引起的,由此判断是队列空了;

    方法二:用两个定义区分对列是满的还是空的,定义当Q.front = Q.rare时,表示队列空了;定义当Q.front = (rare + 1)%SIZE 或(front == -1 &&rare = SIZE -2)时是满的,也就是front指向队头,rare指向队尾,front在rare的下一位置即环状位置的下一个位置,这样下来实际使用的空间是SIZE – 1;

    方法三:很简单的方法,就是记一下进入队列的数number,当进入的个数 = SIZE则说明是满的,当进入个数 = 0,则是空的;

     

    展开全文
  • 方法一:设置一个标志tag,当每一次入队的时候,令tag = 1;...方法二:用两个定义区分列是的还是的,定义当Q.front = Q.rare时,表示队列空了;定义当Q.front = (rare + 1)%SIZE 或(front == -1 &&

    方法一:设置一个标志tag,当每一次入队的时候,令tag = 1;当出队的时候,tag = 0;所以,如果在tag = 1后,Q.front = Q.rare,则说明是因为插队而引起的,所以是因为队列满了;反之,tag = 0时,Q.front = Q.rare,则说明是因为出队引起的,由此判断是队列空了;方法二:用两个定义区分对列是满的还是空的,定义当Q.front = Q.rare时,表示队列空了;定义当Q.front = (rare + 1)%SIZE 或(front == -1 &&rare = SIZE -2)时是满的,也就是front指向队头,rare指向队尾,front在rare的下一位置即环状位置的下一个位置,这样下来实际使用的空间是SIZE – 1;方法三:很简单的方法,就是记一下进入队列的数number,当进入的个数 = SIZE则说明是满的,当进入个数 = 0,则是空的;

    展开全文
  • 本周的作业要求: 1.给出循环队列的存储结构定义。 2.完成循环队列的基本操作函数。... 4) 采用下面两种方法实现对满和队的判断操作: 方法一:修改队满条件,浪费一个元素空间,队满时数组中只有一个...

    本周的作业要求:

    1.给出循环队列的存储结构定义。
    2.完成循环队列的基本操作函数。
             1)      初始化循环队列;
             2)      建立循环队列;
             3)      实现入队和出队操作;
             4)     采用下面两种方法实现对满和队空的判断操作:
       方法一:修改队满条件,浪费一个元素空间,队满时数组中只有一个空闲单元(必做);
       方法二:设置标志flag,当front==rear且flag=0时为队空,当front==rear且flag=1时为队满(必做);
     
    3.编写主函数实现基本操作函数功能,并设置测试数据,测试合法和非法数据的输出结果;
    4.程序调试运行并保存输出结果;
    5.提交实验作业。
     

    方法一:修改队满条件,浪费一个元素空间,队满时数组中只有一个空闲单元(必做);

      1 #include <cstdio>
      2 #include <cstdlib>
      3 #include <cstring>
      4 #define MAXSIZE 50
      5 typedef struct
      6 {
      7     char a[MAXSIZE];
      8     int front;
      9     int rear;
     10 }SeqQueue;
     11 
     12 int flag=0;
     13 
     14 void deng(SeqQueue *Q);
     15 
     16 void duiman(SeqQueue *Q)
     17 {
     18     printf("队满,插入失败,返回登录界面\n");
     19     deng(Q);
     20 }
     21 
     22 void duikong(SeqQueue *Q)
     23 {
     24     printf("队空,无元素出队,返回登陆界面\n");
     25     flag=0;
     26     deng(Q);
     27 }
     28 
     29 void EnterQueue(SeqQueue *Q,char x)
     30 {
     31     if((Q->rear +1)%MAXSIZE==Q->front)
     32         duiman(Q);
     33     Q->a[Q->rear]=x;
     34     Q->rear=(Q->rear+1)%MAXSIZE;
     35     return;
     36 }
     37 
     38 void DeleteQueue(SeqQueue *Q)
     39 {
     40     char x;
     41     if(Q->front==Q->rear)
     42         duikong(Q);
     43     x=Q->a[Q->front];
     44     Q->front=(Q->front+1)%MAXSIZE;
     45     if(flag==0){
     46         flag=1;
     47         DeleteQueue(Q);
     48     }else
     49         printf("出队的队头元素为%c\n",x);
     50     deng(Q);
     51 }
     52 
     53 void ru(SeqQueue *Q)
     54 {
     55     printf("输入入队元素以$结束\n");
     56     char En[MAXSIZE];
     57     int i;
     58     for(i=0;i<MAXSIZE;i++){
     59         scanf("%c",&En[i]);
     60         if(En[i]!='$'){
     61             EnterQueue(Q,En[i]);
     62         }
     63         else
     64             break;
     65     }
     66     printf("入队成功!\n");
     67     deng(Q);
     68 }
     69 
     70 void InitQueue(SeqQueue *Q)
     71 {
     72     Q->front=Q->rear=0;
     73 }
     74 
     75 void deng(SeqQueue *Q)
     76 {
     77     printf("1.入队\n");
     78     printf("2.使队头元素出队,并返回它的值\n");
     79     printf("3.退出\n");
     80     int a;
     81     scanf("%d",&a);
     82     switch(a)
     83     {
     84     case 1:
     85         system("CLS");
     86         ru(Q);
     87     case 2:
     88         system("CLS");
     89         DeleteQueue(Q);
     90     case 3:
     91         exit(0);
     92     default:
     93         printf("输入不合法,请重新输入\n");
     94         deng(Q);
     95     }
     96 }
     97 
     98 
     99 int main()
    100 {
    101     SeqQueue Q;
    102     InitQueue(&Q);
    103     deng(&Q);
    104 
    105     return 0;
    106 }

    方法二:设置标志flag,当front==rear且flag=0时为队空,当front==rear且flag=1时为队满(必做);

      1 #include <cstdio>
      2 #include <cstdlib>
      3 #include <cstring>
      4 #define MAXSIZE 50
      5 typedef struct
      6 {
      7     char a[MAXSIZE];
      8     int front;
      9     int rear;
     10 }SeqQueue;
     11 
     12 int flag=0,tag=0;
     13 
     14 
     15 void deng(SeqQueue *Q);
     16 
     17 void duiman(SeqQueue *Q)
     18 {
     19     printf("队满,插入失败,返回登录界面\n");
     20     deng(Q);
     21 }
     22 
     23 void duikong(SeqQueue *Q)
     24 {
     25     printf("队空,无元素出队,返回登陆界面\n");
     26     flag=0;
     27     deng(Q);
     28 }
     29 
     30 void EnterQueue(SeqQueue *Q,char x)
     31 {
     32     if(tag==1&&Q->front==Q->rear)
     33         duiman(Q);
     34     Q->a[Q->rear]=x;
     35     Q->rear=(Q->rear+1)%MAXSIZE;
     36     return;
     37 }
     38 
     39 void DeleteQueue(SeqQueue *Q)
     40 {
     41     char x;
     42     if(tag==0&&Q->front==Q->rear)
     43         duikong(Q);
     44     x=Q->a[Q->front];
     45     Q->front=(Q->front+1)%MAXSIZE;
     46     if(flag==0){
     47         flag=1;
     48         DeleteQueue(Q);
     49     }else{
     50         tag=0;
     51         printf("出队的队头元素为%c\n",x);
     52     }
     53     deng(Q);
     54 }
     55 
     56 void ru(SeqQueue *Q)
     57 {
     58     printf("输入入队元素以$结束\n");
     59     char En[MAXSIZE];
     60     int i;
     61     for(i=0;i<MAXSIZE;i++){
     62         scanf("%c",&En[i]);
     63         if(En[i]!='$'){
     64             EnterQueue(Q,En[i]);
     65         }
     66         else
     67             break;
     68     }
     69     tag=1;
     70     printf("入队成功!\n");
     71     deng(Q);
     72 }
     73 
     74 void InitQueue(SeqQueue *Q)
     75 {
     76     Q->front=Q->rear=0;
     77 }
     78 
     79 void deng(SeqQueue *Q)
     80 {
     81     printf("1.入队\n");
     82     printf("2.使队头元素出队,并返回它的值\n");
     83     printf("3.退出\n");
     84     int a;
     85     scanf("%d",&a);
     86     switch(a)
     87     {
     88     case 1:
     89         system("CLS");
     90         ru(Q);
     91     case 2:
     92         system("CLS");
     93         DeleteQueue(Q);
     94     case 3:
     95         exit(0);
     96     default:
     97         printf("输入不合法,请重新输入\n");
     98         deng(Q);
     99     }
    100 }
    101 
    102 
    103 int main()
    104 {
    105     SeqQueue Q;
    106     InitQueue(&Q);
    107     deng(&Q);
    108 
    109     return 0;
    110 }

     

    转载于:https://www.cnblogs.com/xzt6/p/5991459.html

    展开全文
  • 循环队列

    2018-08-15 19:50:00
    //循环队列/*循环队列需要注意的几点:1....无论是对循环队列进行插入或者删除操作,均可能涉及到尾指针或者头指针的调整(并且不是简单指针进行+1操作) Q->rear = (Q->rear+1) % Q->queuesiz...

    //循环队列
    /*
    循环队列需要注意的几点:
    1.如果Q->front == Q->rear,则可以判断队列为空
    2.如果 (Q->rear+1)%Q->maxsize 则可以判断队满
    3.无论是对循环队列进行插入或者删除操作,均可能涉及到尾指针或者头指针的调整
    (并且不是简单对指针进行+1操作)
    Q->rear = (Q->rear+1) % Q->queuesize;//入队
    Q->front = (Q->front+1) % Q->queuesize;//出队
    4.循环队列的长度(Q->rear-Q->front+MAXQSIZE)%MAXQSIZE;
    当Q->rear>Q->front时,循环队列的长度为Q->rear-Q->front
    当Q->rear<Q->front时,循环队列的长度为Q->front-Q->front+MAXQSIZE
    综合上述两种情况,得出循环队列长度的计算方法

        队列(包括循环队列)是一个逻辑概念,而链表是个存储概念。一个队列是否是循环队列
            不取决于它将采用何种存储结构,根据需要,循环队列可以采用链式存储结构,
            也可以采用链式存储结构(包括循环链表) 

    */
    #include<stdio.h>
    #include<malloc.h>

    #define MAXQSIZE 50//最大队列长度
    #define ERROR 0
    #define OK 1

    typedef int ElemType;
    typedef int Status;

    typedef struct{
    ElemType *base;
    int front;//头指针,若队列不空指向队头元素
    int rear;//尾指针,若队列不空指向队列尾元素的下一个位置
    int queuesize;
    }SqQueue;

    /
    函数声明
    /
    Status InitQueue(SqQueue Q,int maxsize);
    Status EnQueue(SqQueue
    Q,ElemType e);
    Status DeQueue(SqQueue Q);
    Status Traverse(SqQueue
    Q);
    /
    主函数
    /
    int main(void){
    SqQueue Q;
    InitQueue(&Q,MAXQSIZE);
    for(int i = 0; i<10; i++){
    EnQueue(&Q,i+2);
    }
    for(int i = 0; i<=10; i++){
    DeQueue(&Q);
    }
    }

    /*
    函数实现 
    */
    //初始化队列
    Status InitQueue(SqQueue *Q,int maxsize){
        Q->base = (ElemType*)malloc(MAXQSIZE*sizeof(ElemType));
        if(!Q){
            printf("初始化循环队列时分配空间失败!\n");
            return ERROR;
        }
        Q->queuesize = maxsize;
        Q->front = Q->rear = 0;
        printf("初始化循环队列成功!\n");
        return OK;
    } 
    
    //入队
    //判断队满的条件:
    //      在循环队列中少用一个空间,当当前队尾指针指向位置+1之后%队列长度为队头指针位置表示队满 
    Status EnQueue(SqQueue *Q,ElemType e){
        if((Q->rear+1) % Q->queuesize == Q->front){ 
            printf("循环队列队满!\n");
            return ERROR; 
        }
        Q->base[Q->rear] = e;//将元素插入到队尾 
        printf("当前入队元素:%d\n",Q->base[Q->rear]);
        Q->rear = (Q->rear+1) % Q->queuesize;
    //  Traverse(Q);
        return OK;
    } 
    
    //出队
    Status DeQueue(SqQueue *Q){
        //队列不空,删除队头元素
        if(Q->front == Q->rear){
            printf("当前队列为空,出队失败!\n");
            return ERROR; 
        } 
        ElemType elem;
        elem = Q->base[Q->front];
        Q->front = (Q->front+1) % Q->queuesize;
        printf("当前出队元素:%d\n",elem);
        Traverse(Q);
        return OK;
    } 
    
    Status Traverse(SqQueue *Q){
        if(Q->front == Q->rear){
            printf("当前队列为空!\n");
            return ERROR; 
        }
        int p = Q->front;
        printf("队列中的元素:"); 
        while(p != Q->rear){
            printf("-[%d]",Q->base[p++]);
        }
        printf("\n");
        return OK;
    }

    转载于:https://blog.51cto.com/12012875/2160424

    展开全文
  • 假设Q[0,5]是一个循环队列,初始状态为front=rear=0,请画出做完下列操作后队列的头尾指针的状态变化情况,若不能入,请指出其元素,并说明理由。d, e, b, g, h入队d, e出队i , j , k , l , m入队b出队n, o, p, q,...
  • 循环队列是用一个数组来实现队列,是原来基础上的一个优化 初始front=rear=-1,front表示队列的最前端的前一个位置,rear表示队列的最后一个位置 循环队列可以使得数组中的每一个空间都被充分利用 循环队列中的...
  • C语言实现循环队列

    2019-02-27 17:31:00
    今日在处理数据存储的问题中,数据占用的空间较大,在询问之下,提及循环队列。 没有学习过的我,想想就是头大,只能慢慢从网上找资料,一个字母一个字母的敲...在对循环队列操作之前,先要建立队列结构体元素, ...
  • 重点的标注都在代码中,其中最为重要的内容为: 1.入队和出队的操作:(q->front+1)%MAXSIZE (q->rear+1)%MAXSIZE 2.判和判: ------ 队: 队 从逻辑上表示两者均是 front= rear ;...
  • 设计循环队列

    2019-09-06 00:46:20
    循环队列 2.(队列空间大小为m时,有m-1个元素就认为是队。这样当头尾指针的值相同时,则认为对空;当尾指针在循环意义上加1后是等于头指针,则认为队) 当添加一个元素时,(queue.rear + 1) % maxSize; 当删除...
  • 循环队列的操作

    2020-02-18 13:43:29
    本文对循环队列的重要操作作出总结。注:为了避免队列两个状态混淆, 采用空闲一个位置的方式,即N个元素空间的循环队列最多只能存放N-1个有效元素。这也是大多数教材的做法。 1) 循环队列初始化:front=rear=...
  • 循环队列的实现

    2015-08-20 15:43:37
    使用数组实现一个循环队列,实现的方法包括:队列的初始化、元素进队列、元素出队列、队列判、队列判、取队头元素、取队尾元素、  遍历队列并各数据项调用visit函数、队列置 代码如下(C实现): ...
  • 循环队列操作

    2012-09-20 14:06:00
    注:为了避免队列两个状态混淆, 采用空闲一个位置的方式,即N个元素空间的循环队列最多只能存放N-1个有效元素。这也是大多数教材的做法。 1) 循环队列初始化:front=rear=0; 2)入队操作:rear=(rear+1)%...
  • 解决循环队列的队和队的方法: [1].增加一个参数count,用来记录数组中当前元素的个数; [2].为避免队两状态混淆,少用一个存储空间,也就是数组最后一个存数空间不用,(rear+1)% QSIZE= front 时,...
  • 队列是一种先进先出的的数据结构,我们同样可以使用数组、链表等来实现。我们可以在队列的尾部进行插入元素,在队列的头部取出元素。普通的队列由于空间利用率不高,... 我判断队的方法:牺牲一个单元来区分对空
  • 队列 逻辑结构:线性表 存储结构:顺序存储\链式存储 基本运算: 初始化 判断队 判断队 入队 ...注意:队列也是线性表,其特殊性在于有特殊的运算规则。...1.循环队列 之所以用循环列,就是了为了提高利用率。...
  • 数据结构与算法系列-队列-循环队列

    千次阅读 2013-11-10 22:14:43
    定义: 循环队列: ...在循环队列中 容量设为MANLEN,首指针为front 队尾指针为rear 当rear=front时 不能判定循环队列还是为,对此做出规定 front = rear 是循环队列为的标志.(rear+!)
  • 循环队列实际上就是抛弃一个点作为队列的标记 当尾标记再挪动一位取模就要等于头标记时,就代表队列已经了。 当尾标记和头标记在同一位置时,就表示队列为 除此之外,插入队列时必须尾标记取模。抛出队列时...
  • 四个属性: private int maxSize; // 表示数组的最大容量 private int front; // 队列头 private int rear; // 队列尾 private int[] arr; // 该数据用于存放数据, 模拟队列 ...:rear=front; package com.at...
  • 是否,empty和full我未写到方法里面。每次都需要额外size进行操 作,高性能场景还是有部分性能损失。 front指向可用的元素,rear指向下一个可用的元素。 class QueueS{ private int max; private l...
  • 数组实现循环队列

    千次阅读 2017-09-23 13:07:21
    1、为了有效的处理队列,我们需要两个...由于在循环数组中,入队时队尾追赶队首,出队时队首追赶队尾,当队或队时都有front == rear, 故无法用此作为判定标准  解决办法: (1)留空位。当队列还有一个
  • C语言-循环队列的简单实现

    千次阅读 2015-03-04 22:02:47
    用C语言实现一个循环队列并不难。关键点在于队列 "" 和 "" 状态的判断。 正如《C和指针》中所描写的,有两种方法来实现队列状态的判断。 在数组中空一个元素不填,起始时, 置tail为0, front为1, ...
  • C++ 无尾指针循环队列

    2020-01-03 19:21:27
    对空判断条件是: count==0 队判断条件是: count==MAX #include <iostream> using namespace std; #define MAX 5 //没有队尾指针循环队列 //增加一个计数器表示数列中元素的数量 struct ...
  • 循环队列中,需要队为和队为的时候进行判断,为了区分队和队两个条件,需要浪费capacity一个空间,让rear指针一直指向一个的位置; 当 rear= =front 时,队为; 当 (rear+1)%n= =front (n为数字...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 131
精华内容 52
关键字:

循环队列对空对满