循环队列

题目： 思路： 不是每次都进行数字搬移(直到后面没空间了再一次性搬移到前面) //数组中实现对列 class MyCircularQueue { private int [ ] array ; //存储空间 private int size ; //当前数据个数 private int front ; //指向队首下标 private int rear ; //指向队尾下一个可用空间 /** Initialize your data structure here. Set the size of the queue to be k. */ public MyCircularQueue ( int k ) { //容量 array = new int [ k ] ; size = 0 ; front = 0 ; rear = 0 ; } /** Insert an element into the circular queue. Return true if the operation is successful. */ public boolean enQueue ( int value ) { //插入成功返回true if ( size == array . length ) { //满了不成功 return false ; } array [ rear ] = value ;

以下说法都是 针对顺序存储结构实现的队列 先理清思路 （1）普通队列的元素满足：存储在数组的前n个单元 这一条件，因此队列元素出列时，由于队列元素都得向前移动，因此需要O（n）时间 （2）为了省去O（n）时间，引入front与rear指针，分别指向队头元素、队尾元素的 下一个位置 。 而rear不是指向队尾元素而是指向其下一个位置的原因是：避免当只有一个元素时， 队头和队尾重合 使处理变麻烦；当遵循上述规则时出现 front = rear，则证明 是空队列而不是只有一个元素 空队列 0 1 2 3 4 5 front rear ↓ ↓ 只有一个元素： 0 1 2 3 4 5 front rear ↓ ↓ a1 （3）但（2）的结构有缺点，因为无需限制队列的元素必须存储在数组的前n个单元的条件，当队列中进行若干进队出队操作后，front、rear指针就会不断后移，直至rear指针越界时，是否说明队列已满，已无可用空间？答案当然是NO！因为 front指针前的数组位置都是可用的 ，这种现象称为 假溢出 0 1 2 3 4 5 front rear ↓ ↓ a3 a4 a5 a6 ？ （4）解决假溢出的办法，就是后面满了，再从头开始，即头尾相接的循环。把队列的这种头尾相接的顺序存储结构称为 循环队列 。 至此，循环队列应运而生。 那么问题又来了，按循环队列的规则实现后，（2

循环队列 1 #include<stdio.h> 2 #include<stdlib.h> 3 #include<malloc.h> 4 5 typedef struct Queue 6 { 7 int * pBase; 8 int front; 9 int rear; 10 }QUEUE; 11 12 void init_Queue(QUEUE *); 13 bool en_Queue(QUEUE *,int val); //入队 14 void traverse_Queue(QUEUE *); 15 bool full_Queue(QUEUE *); 16 bool out_Queue(QUEUE *,int*); //出队 17 bool empty_Queue(QUEUE *Qu); 18 19 int main(void) 20 { 21 QUEUE Q; 22 int val; 23 24 init_Queue(&Q); 25 26 printf("入队元素是:"); 27 en_Queue(&Q,1); 28 en_Queue(&Q,2); 29 en_Queue(&Q,3); 30 en_Queue(&Q,4); 31 en_Queue(&Q,5); 32 en_Queue(&Q,6); 33 en_Queue(&Q,7); 34 en_Queue(&Q,8);

文章目录 一、引入 二、循环队列基本操作 三、循环队列简单实现 一、引入 队列的顺序表示和实现 队列的顺序表示-用一维数组base[MAXQSIZE] # define MAXQSIZE 100 //最大队列长 typedef struct { Qelem * base ; //初始化的动态分配存储空间 int front ; //头指针，不是指针变量，若队列不空，只想队头元素 int rear ; //尾指针，不是指针变量，若队列不空，指向队尾元素的下一个位置 } SqQueue ; 初始： front = rear = 0 ; //队空 入队： base [ Q . rear ] = e ; // rear ++ ; //指向下一空间 出队： e = base [ Q . front ] ; //出队 front ++ ; front = rear ; //队空标志 当rear==MAXQSIZE时，发生溢出 若front=0,rear=MAXQSIZE时，再入队——真溢出； 若front!=0,rear=MAXQSZIE时，再入队—— 假溢出 如何解决假溢出问题？ 将队中元素向对头移动，缺点是浪费时间，队中元素都要移动 将队空间设想成一个循环的表，即分配给队列的m个存储单元可以循环使用，当 rear = =MAXQSIZE 时，若向量的开始端空着，又可从头使用空着的空间。当

队列 ：只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 1.循环队列 　　队列的 顺序储存结构 ：用数组存储队列，引入front指针指向队头元素，rear指针指向队尾元素的下一个位置，当front=rear时，为空队列，结构如下图所示。　 　　当执行入队操作时，若数组尾部已满，而数组前部因有元素出队而有空位时，我们把新插入的元素从头开始入队，这样就类似于头尾相接的结构。 　　队列的这种头尾相接的顺序存储结构称为 循环队列 ，如下图所示。 　　上面队列的定义中提到，当front=rear时，为空队列，而在循环队列中，队列满时，front也等于rear，将无法判断队满和空的情况。 一种办法是设置一个标志变量flag，当front=rear时，通过判断flag是0还是1来确定队列满空情况； 另一种方法是，在数组中只剩一个空闲单位时，定义为队列满，如下图所示。（本文程序采用这种办法） 因为rear可能比front大，也可能比front小，所以队列满的条件应该为： (rear+1)%maxSize==fron t；同理，队列长度的计算公式为： (rear-front+maxSize)%maxSize 。 实现程序： /** * <循环队列> * * 注意点：表长的表示、队列满的判断、front和rear的改变 * */ public class SqQueue<E> {

package Demo; //性能最优的循环队列 public class Queue { private int[] data = new int[20]; private int start = 0; private int end = 0; public void push(int newint) { if( end - start == data.length) { int[] datanew = new int[data.length * 2]; for(int i = 0; i < data.length;i++) { datanew[i] = data[(start + i) % data.length]; } start = 0; end = start + data.length; data = datanew; } data[end % data.length] = newint; end++; } public Integer get() { if(end == start) { return null; } int result = data[start % data.length]; start++; return result; } } 来源： CSDN 作者： 薛习 链接： https://blog.csdn.net/weixin_45681935

在非空队列里，队首指针始终指向队头元素，而队尾指针始终指向队尾元素的下一位置。 顺序队列中存在“假溢出”现象。因为在入队和出队操作中，头、尾指针只增加不减小，致使被删除元素的空间永远无法重新利用。因此，尽管队列中实际元素个数可能远远小于数组大小，但可能由于尾指针巳超出向量空间的上界而不能做入队操作。该现象称为假溢出。如下图所示是数组大小为5的顺序队列中队首、队尾指针和队列中元素的变化情况 为了解决假溢出问题，采用循环队列，看下图 入队时尾指针向前追赶头指针，出队时头指针向前追赶尾指针，故队空和队满时头尾指针均相等。因此，无法通过front=rear来判断队列“空”还是“满”。解决此问题的方法是：约定入队前，测试尾指针在循环意义下加1后是否等于头指针，若相等则认为队满。 即rear所指的单元始终为空。 判断是否队满(入队操作尾指针) (q.rear+1)%MAX == q.front q.rear = (q.rear+1)%MAX 判断是否队空(出队操作头指针) q.front==q.rear q.front = (q.front+1)%MAX # include <iostream> using namespace std ; # define MAX 5 //循环队列 struct Queue { int data [ MAX ] ; int front ; //队首指针 int

队列:先进先出 function Queue ( len ) { let _arr = new Array ( len + 1 ) ; let front = 0 ; let rear = 0 ; this . enQueue = function ( item ) { if ( this . isFull ( ) ) { console . log ( '队列已满!' ) ; return false ; } _arr [ rear ] = item ; rear = ( rear + 1 ) % _arr . length ; } this . deQueue = function ( ) { if ( this . isEmpty ( ) ) { console . log ( '队列为空!' ) ; return false ; } let item = _arr [ front ] ; front = ( front + 1 ) % _arr . length ; return item ; } this . isEmpty = function ( ) { return front === rear ; } this . isFull = function ( ) { return ( rear + 1 ) % _arr . length === front ; } }

顾名思义，循环队列是一种队列。 循环队列常用于服务器用户排队等待情况。 循环队列具有头指针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不需要指向后一个元素。 来源： CSDN 作者： shelven丶 链接： https://blog

链队列 队列的链式存储结构，其实就是线性表的单链表，只不过它只能它只能尾进头出而已，我们把它就称之为链队列。 既然链队列和单链表一样，观察链队列LinkedQueue和单链表LinkedList的UML类图，可以看到两者之间是聚合关系，也就说LinkedQueue相当于LinkedList的成员变量，和我们的之前说的链栈是一样的 既然如此，也是创建LinkedList对象list实现，调用list的方法即可，当然LinkedQueue还有实现Queue接口 package DS02 . 动态链表 ; import DS01 . 动态数组 . Queue ; import java . util . Iterator ; public class LinkedQueue < E > implements Queue < E > { //声明并创建单链表对象 private LinkedList < E > list ; public LinkedQueue ( ) { list = new LinkedList < > ( ) ; } @Override public int getSize ( ) { return list . getSize ( ) ; } @Override public boolean isEmpty ( ) { return list . isEmpty