精华内容
下载资源
问答
  • 循环队列的队空与队满的条件

    千次阅读 2014-07-19 00:29:15
     因此只凭等式front=rear无法判断队空还是队满。 有两种方法处理上述问题:  (1)另设一个标志位以区别队列是空还是满。  (2)少用一个元素空间,约定以“队列头指针front在队尾指针rear下一个位

    为了方便起见,约定:初始化建空队时,令
          front=rear=0,
      当队空时:front=rear
      当队满时:front=rear 亦成立
      因此只凭等式front=rear无法判断队空还是队满。  有两种方法处理上述问题:
        (1)另设一个标志位以区别队列是空还是满。
        (2)少用一个元素空间,约定以“队列头指针front在队尾指针rear的下一个位置上”作为队列“满”状态的标志。即:
      队空时: front=rear
      队满时: (rear+1)%maxsize=front

      front指向队首元素,rear指向队尾元素的下一个元素。

      

     

    1. /  
    2. //   
    3. // author: kangquan2008@csdn  
    4. //  
    5. /  
    6. #include <stdio.h>  
    7. #include <stdlib.h>  
    8. #include <stdbool.h>  
    9.   
    10. #define QUEUE_SIZE 10  
    11. #define EN_QUEUE 1  
    12. #define DE_QUEUE 2  
    13. #define EXIT     3  
    14.   
    15. typedef int    Item;  
    16. typedef struct QUEUE{  
    17.   
    18.     Item * item;  
    19.     int front;  
    20.     int tear;  
    21.   
    22. }Queue;  
    23.   
    24. int init_queue(Queue * queue)  
    25. {  
    26.     queue->item = malloc(QUEUE_SIZE * sizeof(Item));  
    27.     if(!queue->item)  
    28.     {  
    29.         printf("%s\n","Alloc failed,not memory enough");  
    30.         exit(EXIT_FAILURE);  
    31.     }  
    32.   
    33.     queue->front = queue->tear = 0;  
    34.   
    35.     return 1;  
    36. }  
    37.   
    38. int en_queue(Queue * queue, Item item)  
    39. {  
    40.     if((queue->tear+1) % QUEUE_SIZE == queue->front)  
    41.     {  
    42.         printf("%s\n","The queue is full");  
    43.         return -1;  
    44.     }  
    45.   
    46.     queue->item[queue->tear] = item;  
    47.     queue->tear = (queue->tear + 1) % QUEUE_SIZE;  
    48.   
    49.     return 1;  
    50. }  
    51.   
    52. int de_queue(Queue * queue, Item * item)  
    53. {  
    54.     if(queue->front == queue->tear)  
    55.     {  
    56.         printf("%s\n","The queue is empty");  
    57.         return -1;  
    58.     }  
    59.   
    60.     (*item) = queue->item[queue->front];  
    61.     queue->front = (queue->front + 1) % QUEUE_SIZE;  
    62.   
    63.     return 1;  
    64. }  
    65.   
    66. int destroy_queue(Queue * queue)  
    67. {  
    68.     free(queue->item);  
    69. }  
    70.   
    71. int main()  
    72. {  
    73.     Queue que;  
    74.     init_queue(&que);  
    75.     int elem;  
    76.     bool flag = true;  
    77.     while(flag)  
    78.     {  
    79.         int choice;  
    80.         printf("1 for en_queue,2 for de_queue,3 for exit\r\nplease input:");  
    81.         scanf("%d",&choice);  
    82.   
    83.         switch((choice))  
    84.         {  
    85.             case EN_QUEUE:  
    86.                 printf("input a num:");  
    87.                 scanf("%d",&elem);  
    88.                 en_queue(&que,elem);  
    89.                 break;  
    90.             case DE_QUEUE:  
    91.                 if(de_queue(&que,&elem) == 1)  
    92.                     printf("front item is:%d\n",elem);  
    93.                 break;  
    94.             case EXIT:  
    95.                 flag = false;  
    96.                 break;  
    97.             default:  
    98.                 printf("error input\n");  
    99.                 break;  
    100.         }  
    101.     }  
    102.   
    103.     destroy_queue(&que);  
    104.     return 0;  
    105. }  
    展开全文
  • 约定:初始化建空队时,令 front=rear=0, 当队空时:front=rear 当队满时:front=rear 亦成立 因此只凭等式front=rear无法判断队空还是队满。 有两种方法处理上述问题: (1)另设一个标志位以...

     转
    http://blog.csdn.net/kangquan2008/article/details/5719529

    为了方便起见,约定:初始化建空队时,令
          front=rear=0,
      当队空时:front=rear
      当队满时:front=rear 亦成立
      因此只凭等式front=rear无法判断队空还是队满。  有两种方法处理上述问题:
        (1)另设一个标志位以区别队列是空还是满。
        (2)少用一个元素空间,约定以“队列头指针front在队尾指针rear的下一个位置上”作为队列“满”状态的标志。即:
      队空时: front=rear
      队满时: (rear+1)%maxsize=front 

      front指向队首元素,rear指向队尾元素的下一个元素。 

     

    /
    // 
    // author: kangquan2008@csdn
    //
    /
    #include <stdio.h>
    #include <stdlib.h>
    #include <stdbool.h>
    
    #define QUEUE_SIZE 10
    #define EN_QUEUE 1
    #define DE_QUEUE 2
    #define EXIT     3
    
    typedef int    Item;
    typedef struct QUEUE{
    
    	Item * item;
    	int front;
    	int tear;
    
    }Queue;
    
    int init_queue(Queue * queue)
    {
    	queue->item = malloc(QUEUE_SIZE * sizeof(Item));
    	if(!queue->item)
    	{
    		printf("%s\n","Alloc failed,not memory enough");
    		exit(EXIT_FAILURE);
    	}
    
    	queue->front = queue->tear = 0;
    
    	return 1;
    }
    
    int en_queue(Queue * queue, Item item)
    {
    	if((queue->tear+1) % QUEUE_SIZE == queue->front)
    	{
    		printf("%s\n","The queue is full");
    		return -1;
    	}
    
    	queue->item[queue->tear] = item;
    	queue->tear = (queue->tear + 1) % QUEUE_SIZE;
    
    	return 1;
    }
    
    int de_queue(Queue * queue, Item * item)
    {
    	if(queue->front == queue->tear)
    	{
    		printf("%s\n","The queue is empty");
    		return -1;
    	}
    
    	(*item) = queue->item[queue->front];
    	queue->front = (queue->front + 1) % QUEUE_SIZE;
    
    	return 1;
    }
    
    int destroy_queue(Queue * queue)
    {
    	free(queue->item);
    }
    
    int main()
    {
    	Queue que;
    	init_queue(&que);
    	int elem;
    	bool flag = true;
    	while(flag)
    	{
    		int choice;
    		printf("1 for en_queue,2 for de_queue,3 for exit\r\nplease input:");
    		scanf("%d",&choice);
    
    		switch((choice))
    		{
    			case EN_QUEUE:
    				printf("input a num:");
    				scanf("%d",&elem);
    				en_queue(&que,elem);
    				break;
    			case DE_QUEUE:
    				if(de_queue(&que,&elem) == 1)
    					printf("front item is:%d\n",elem);
    				break;
    			case EXIT:
    				flag = false;
    				break;
    			default:
    				printf("error input\n");
    				break;
    		}
    	}
    
    	destroy_queue(&que);
    	return 0;
    }
    
    
    

     

     

    展开全文
  • 队列满与空的条件

    千次阅读 2018-07-25 21:11:29
    充分利用队列的存储空间,我们可以把队列想象成一个首尾相接的圆环,即将队列中的第一个元素... 队满的条件:(rear+1)%MaxSize = front(此时,循环队列中能装入的元素的个数为MaxSize)  队空的条件:rear=front...

    充分利用队列的存储空间,我们可以把队列想象成一个首尾相接的圆环,即将队列中的第一个元素接在最后一个元素的后面,我们称这样的队列为循环队列;

           队满的条件:(rear+1)%MaxSize = front(此时,循环队列中能装入的元素的个数为MaxSize)

        队空的条件:rear=front

    展开全文
  • 循环队列队队空的判定

    千次阅读 2014-09-21 10:18:13
    循环队列的队空与队满的条件 分类: 数据结构与算法2010-07-07 21:31 8976人阅读 评论(3) 收藏 举报 inputstruct 为了方便起见,约定:初始化建空队时,令  front=rear=0,  当队空时:front...
     

    循环队列的队空与队满的条件

    分类: 数据结构与算法 8976人阅读 评论(3) 收藏 举报

    为了方便起见,约定:初始化建空队时,令
          front=rear=0,
      当队空时:front=rear
      当队满时:front=rear 亦成立
      因此只凭等式front=rear无法判断队空还是队满。  有两种方法处理上述问题:
        (1)另设一个标志位以区别队列是空还是满。
        (2)少用一个元素空间,约定以“队列头指针front在队尾指针rear的下一个位置上”作为队列“满”状态的标志。即:
      队空时: front=rear
      队满时: (rear+1)%maxsize=front

      front指向队首元素,rear指向队尾元素的下一个元素。

      

     

    1. /  
    2. //   
    3. // author: kangquan2008@csdn  
    4. //  
    5. /  
    6. #include <stdio.h>  
    7. #include <stdlib.h>  
    8. #include <stdbool.h>  
    9.   
    10. #define QUEUE_SIZE 10  
    11. #define EN_QUEUE 1  
    12. #define DE_QUEUE 2  
    13. #define EXIT     3  
    14.   
    15. typedef int    Item;  
    16. typedef struct QUEUE{  
    17.   
    18.     Item * item;  
    19.     int front;  
    20.     int tear;  
    21.   
    22. }Queue;  
    23.   
    24. int init_queue(Queue * queue)  
    25. {  
    26.     queue->item = malloc(QUEUE_SIZE * sizeof(Item));  
    27.     if(!queue->item)  
    28.     {  
    29.         printf("%s\n","Alloc failed,not memory enough");  
    30.         exit(EXIT_FAILURE);  
    31.     }  
    32.   
    33.     queue->front = queue->tear = 0;  
    34.   
    35.     return 1;  
    36. }  
    37.   
    38. int en_queue(Queue * queue, Item item)  
    39. {  
    40.     if((queue->tear+1) % QUEUE_SIZE == queue->front)  
    41.     {  
    42.         printf("%s\n","The queue is full");  
    43.         return -1;  
    44.     }  
    45.   
    46.     queue->item[queue->tear] = item;  
    47.     queue->tear = (queue->tear + 1) % QUEUE_SIZE;  
    48.   
    49.     return 1;  
    50. }  
    51.   
    52. int de_queue(Queue * queue, Item * item)  
    53. {  
    54.     if(queue->front == queue->tear)  
    55.     {  
    56.         printf("%s\n","The queue is empty");  
    57.         return -1;  
    58.     }  
    59.   
    60.     (*item) = queue->item[queue->front];  
    61.     queue->front = (queue->front + 1) % QUEUE_SIZE;  
    62.   
    63.     return 1;  
    64. }  
    65.   
    66. int destroy_queue(Queue * queue)  
    67. {  
    68.     free(queue->item);  
    69. }  
    70.   
    71. int main()  
    72. {  
    73.     Queue que;  
    74.     init_queue(&que);  
    75.     int elem;  
    76.     bool flag = true;  
    77.     while(flag)  
    78.     {  
    79.         int choice;  
    80.         printf("1 for en_queue,2 for de_queue,3 for exit\r\nplease input:");  
    81.         scanf("%d",&choice);  
    82.   
    83.         switch((choice))  
    84.         {  
    85.             case EN_QUEUE:  
    86.                 printf("input a num:");  
    87.                 scanf("%d",&elem);  
    88.                 en_queue(&que,elem);  
    89.                 break;  
    90.             case DE_QUEUE:  
    91.                 if(de_queue(&que,&elem) == 1)  
    92.                     printf("front item is:%d\n",elem);  
    93.                 break;  
    94.             case EXIT:  
    95.                 flag = false;  
    96.                 break;  
    97.             default:  
    98.                 printf("error input\n");  
    99.                 break;  
    100.         }  
    101.     }  
    102.   
    103.     destroy_queue(&que);  
    104.     return 0;  
    105. }  
    展开全文
  • 思路:利用tag来标记队列空或满的条件如下为: tag等于0时,若因删除导致 Q.front=Q.rear ,则为队空; tag等于1时,若因插入导致Q.front==Q.rear,则为队满队列结构 #define MaxSize 10; typedef struct ...
  • 由于顺序队列有“假溢出”的缺点,所以在应用...循环队列的判读队满的条件是:(Q.rear + 1) % MaxSize == Q.fornt; 下面是队列实现的存储类型结构体: #define MaxSize 50 typedef int ElemType; typedef struct { ...
  •  先进入队列的元素必然先离开队列(先进先出)栈相反 队尾指针指向队尾元素的下一个位置(防止假溢出) 队空条件:front == rear 队满条件:(rear+1) % MaxSize == front 进队:rear =...
  • 循环队列的实现

    2019-07-09 00:12:50
    循环队列的实现: 首先使用数组实现一个循环的队列: 那么出队与入队就变成了移动front和rear。 队列时rear=front 入队时,rear后移一位,array[rear]=data: 出时front后移一位: 队列...
  • 循环队列是队列的一种特殊形式。...循环队列的队空判断条件为 rear == front;判断队满的条件为 (rear +1)%maxSize==front; 二、代码示例 package queue; import java.util.Scanner; public class CircleArrayQueue
  • 循环队列的常见操作

    2018-04-22 19:25:15
    栈相比,队列我个人感觉简单一些,不过对于一般队列,都是循环队列,这是为了...通过该空节点用来区分队满与队空队满是判断条件是(rear+1)% len = front其中rear为队尾数据下标,front为队头下标,len...
  • 队列满的条件:rear == maxSize(队列最大长度)- 1; 队列的条件:rear == front; 队列无法重复使用,一旦首指针后移,之前的空间便无法再次访问,效率低,空间利用率低。 2、循环队列循环队列是在队列的...
  • 则队列满的条件是:(rear+1)%QueueSize==front 则列为的条件为:rear==front 通用的计算队列长度的公式:(rear-front+QueueSize)%QueueSize 则队列的数组实现如下: private int[] array; private int front; ...
  • 队列 1、也是一种操作受限的线性表,规定只能在一端插入,一端删除,有先进先出的特点。 ...1)为了区分队满队空的条件循环队列往往采用少用一个单元进行入队 队满判定条件:(Q.rear+...
  • 循环队列的基本操作

    千次阅读 2019-01-25 16:42:04
    为了解决顺序队列假溢出的问题,我们采用的方案是少用一个元素空间,此时的指针状态是队尾指针加1才与队头指针重合,于是此时队满的判定条件变为(rear+1)%MAXSIZE=front,队空的判定条件依然是front==rear,这样就能...
  • 用数组实现的非循环队列,判断队列满的标准是tail == n,队空的判断条件是head == tail 用数组实现队列的时候需要在新元素入队的时候进行数据搬移操作。 (队列的实现暂时未做) 2. 特殊的队列:循环队列 检测...
  • 出队时头指针向前追赶尾指针,造成队空队满时头尾指针均相等。因此,无法通过条件front==rear来判别队列是"空"还是"满"。 解决这一问题有两种方法 1.设置计数器判断 2.队满时:(rear+1)%n==front,n为队列长度...
  • //顺序队列 //如果循环队列或者顺序队列采用front指向首元素 rear指向尾元素 //会出现当进行出队时,当最后...//当循环队列采用顺序队列方法以rear指向最后一个元素之后位置,出现队满队空条件一样 //出现情况:...
  • 循环队列类:文件名 sq_Queue.h判断队列有无数据根据s的值可判断,如果s=0,则说明为,反之,不为时,还要判断是否为满,满的条件是(s==0&&(rear==front));注意:入队,rear和front 都是加1;#include ...
  • 循环队列的一个重要问题:判断队列是队列的判断比较简单:尾游标等于头游标 队列的判断比较复杂:如果也是用尾游标等于头游标则出现与空队列相同的判断条件,此时可以额外增加判断标志位,还有第二种...
  • /*1、意义上实现循环,则当队尾指针+1对最大空间(数组长度)取模等于队头时,队满,当q.rear=q.front时,队空,两者判断条件不同, 因为当插入满时,q.front=q.rear,与队空时一样。 2、注:入队时,队尾向后追队...
  • ** 把front==rear 仅作为队空的判定条件, ** 当队列满的时候,令数组中仍然保留一个空余单元,我们认为这个时候队列满了 ** (rear+1)%MaxSize == front */ //队列中的元素个数 (rear-front+MaxSi...
  • 3.4.3 循环队列之静态存储空间(2)

    千次阅读 2012-11-07 22:27:15
    为了区分队满与队空,在循环队列中,少用一个存储单元,也就是在最大存储空间为MAX_QSIZE的循环队列中,最多只能存放MAX_QSIZE-1个元素。这样,队列空的条件任为队尾指针等于对头指针,队列满的条件改为(队尾指针+1...
  • 循环队列中,由于入队时尾指针向前追赶头指针;出队时头指针向前追赶尾指针,造成队空...两者都要掌握队列空与满的判定条件以及出队列、入队列操作的实现。为充分利用向量空间,克服"假溢出"现象的方法是:将向量空间想
  • (2)熟悉队列的组织方法,队列、队列的判断条件及其描述; (3)掌握队列的基本操作(入队、出等)。 2.实验内容 (1)假设以数组 sequ[MaxSize]存放环形队列的元素,同时 Rear 和 Len 分别指示 ...
  • 队列的 基本操作

    2017-10-07 23:14:00
    一.原理方法 循环队列的 插入 删除 ...2. 在循环队列中判断队空队满的条件能否一样,为什么? 3. 用另一种不同上面算法的方法解决“假上溢”问题。 #include<stdio.h> # include "stdlib.h" # ...

空空如也

空空如也

1 2 3
收藏数 47
精华内容 18
关键字:

循环队列的队空与队满的条件