精华内容
下载资源
问答
  • Java循环队列的实现方法时间:2017-09-13来源:华清远见JAVA学院生活中有很多队列的影子,比如打饭排队,买火车票排队问题等,可以说与时间相关的问题,一般都会涉及到队列问题。那么Java如何实现循环队列呢?今天...

    Java循环队列的实现方法

    时间:2017-09-13     来源:华清远见JAVA学院

    生活中有很多队列的影子,比如打饭排队,买火车票排队问题等,可以说与时间相关的问题,一般都会涉及到队列问题。那么Java如何实现循环队列呢?今天华清Java学院小编就以Java如何用数组实现循环队列为例,和大家分享一下Java循环队列的实现方法。

    2d62183ab95b7ca0513fd9dff20c9cad.png

    Java循环队列的实现代码如下:

    1、队列的类

    class CirQueue{//循环队列

    private int QueueSize;

    private int front;

    private int rear;

    private int[] queueList ;

    public CirQueue(int QueueSize){

    this.QueueSize = QueueSize;

    queueList = new int[QueueSize];

    front = 0;

    rear = 0;

    }

    public int getQueueElement(){ //获取队列头元素

    //如果队列不为空,返回队头元素,否则抛出异常提示队列为空

    int element = -1;

    if(!isEmpty()){

    element = queueList[front];

    return element;

    }else {

    System.out.println("队列为空");

    return -1;

    }}

    public int deQueue(){//出队

    int element = -1;

    if(!isEmpty()){

    element = queueList[front];

    front =(front+1)%QueueSize;

    return element;

    }

    else {

    System.out.println("队列为空");

    return -1;

    } }

    public void enQueue(int element){//入队

    //如果队列未满,添加元素到队尾,否则提示队列已满

    if(!isFull()){

    queueList[rear] = element ;

    rear = (rear+1)%QueueSize;

    } else {

    System.out.println("队列已满");

    } }

    public boolean isEmpty(){//判断队列是否为空

    boolean b = false;

    if(rear == front)

    b = true;

    return b;

    }

    public boolean isFull(){//判断队列是否已满

    boolean b = false;

    if((rear+1)%QueueSize == front)

    b = true;

    return b;

    }}

    2、创建对象并测试

    package com.test;

    import java.util.*;

    public class StructTest {

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    //新建并初始化存储空间为3的循环队列(方便判断队满条件,浪费一个数组空间)

    CirQueue cirQueue = new CirQueue(4);

    //入队3个元素

    cirQueue.enQueue(1);

    cirQueue.enQueue(2);

    cirQueue.enQueue(3);

    //获取队头元素,获取 但不改变队列

    int temp = cirQueue.getQueueElement();

    System.out.println(temp);

    //出队 获取队头元素,并且队头指针往后移一位

    temp = cirQueue.deQueue();

    System.out.println(temp);

    //再次获取队头元素

    temp = cirQueue.getQueueElement();

    System.out.println(temp);

    }}

    3、输出:

    1 1

    2 1

    3 2

    在看到了网站运营行业的美好发展前景,以及可观的薪资待遇之后,越来越多的人选择从事到这个行业中来。从事一个行业,就首先要掌握它的相关技能

    展开全文
  • 主要介绍了Java循环队列原理与用法,结合实例形式详细分析了Java循环队列基本概念、原理、用法及操作注意事项,需要的朋友可以参考下
  • 下面小编就为大家分享一篇基于Java数组实现循环队列的两种方法小结,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • java队列实现(顺序队列、链式队列、循环队列
  • java循环队列之舞会配对问题

    千次阅读 2019-11-16 15:18:51
    利用循环队列模拟舞伴配对问题。在舞会上,男、女各自排成一队。舞会开始时。依次从男队和女队的队头各出一人配成舞伴。如果两队初始人数不等,则较长的那一队中未配对者等待下一轮舞曲。 假设初始男、女人数及性别...

    题目

    1. 利用循环队列模拟舞伴配对问题。在舞会上,男、女各自排成一队。舞会开始时。依次从男队和女队的队头各出一人配成舞伴。如果两队初始人数不等,则较长的那一队中未配对者等待下一轮舞曲。
    2. 假设初始男、女人数及性别已经固定,舞会的轮数从键盘输入。试模拟解决上述舞伴配对问题。
    3. 从屏幕输出每一轮舞伴配对名单,如果在该轮有未配对的,能够从屏幕显示下一轮第一个出场的未配对者的姓名。

    正确代码

    测试类

    import java.util.Scanner;
    
    public class Test {
    	public static void main(String[] args) {
    		System.out.println("请输入跳舞轮数");
    		Scanner sc=new Scanner(System.in);
    		int round=sc.nextInt();
    		SeqQueue boys=new SeqQueue(10); 
    		SeqQueue girls=new SeqQueue(10);
    		boys.add("b1");
    		boys.add("b2");
    		boys.add("b3");
    		boys.add("b4");
    		boys.add("b5");
    		girls.add("g1");
    		girls.add("g2");
     		girls.add("g3");
    		int j=0;
    		int min=minLength(boys,girls);
    		while(j<round) {
    			for(int i=0;i<min;i++) {
    				String boy=boys.poll();
    				String girl=girls.poll();
    				System.out.println("boy"+boy+"<-->girls"+girl);		
    				boys.add(boy);
    				girls.add(girl);
    			}
    			/**注意
     * 必须要让int min=minLength(boys,girls);的min成为全局变量
     * 这样min就是固定的值,即两个队列中元素最少的那一队的元素个数,
     * 这样你每一次循环min就不变。
     * 如果把int min=minLength(boys,girls);这一行删除,
     * 并且for循环这里的min写成minLength(boys,girls),
     * 那么每一次循环时,队列的front都会向后移动一位,
     * 每次调用minLength,我们发现int aLength=a.rear-a.front;的alength都会减少1,
     * minLength的值在这种情况下就不是固定的,
     * 因此要将min=minLength(boys,girls);写在for的外边。
     * **/
    			System.out.println("没有被配对的第一个人是:"+minSeqQueue(girls, boys).peek());
    			j++;
    		}
    	}
    	private static int minLength(SeqQueue a,SeqQueue b) {
    	//这个比较大小的方法不可以比较队列数组的长度,数组的长度并不是元素的个数
    		int aLength=a.rear-a.front;
    		int bLength=b.rear-b.front;
    
    		if(aLength<bLength) {
    			return aLength;
    		}else {
    			return bLength;
    		}
    	}
    	private static SeqQueue minSeqQueue(SeqQueue a,SeqQueue b) {
    		if(a.element.length<b.element.length) {
    			return a;
    		}else {
    			return b;
    		}
    		// TODO 自动生成的方法存根
    
    	} 
    	
    }
    

    队列类

    public class SeqQueue {
    	String element[];
    	int front,rear;
    	public SeqQueue(int length) {
    		// TODO 自动生成的构造函数存根
    		this.element=new String[length];
    		this.front=this.rear=0;
    	}
    	public boolean isEmpty() {
    		return this.front==this.rear;
    		// TODO 自动生成的方法存根
    
    	}
    	public boolean add(String str) {
    	
    		if(this.front==(this.rear+1)%this.element.length) {
    			String[] temp=this.element;
    			this.element= new String[element.length*2];
    			int j=0;
    			for(int i=this.front;i!=this.rear;i=(i+1)%temp.length) {
    				this.element[j++]=temp[i];
    			}
    			this.front=0;
    			this.rear=j;
    		}
    		this.element[this.rear]=str;
    		
    		this.rear=(this.rear+1)%this.element.length;
    		//System.out.println(this.element.length);
    		return true;
    	}
    	public String peek() {
    		// TODO 自动生成的方法存根
    		return this.isEmpty()?null:this.element[front];
    	}
    	public String poll() {
    		if (isEmpty()) {
    			return null;
    		}
    		int temp=this.front;
    		this.front=(this.front+1)%this.element.length;
    		return this.element[temp];
    	}
    }
    

    add方法的流程图(配合上面的代码看)

    建议把代码copy到IDE中再看此流程图以获得最佳阅读效果,嘻嘻
    在这里插入图片描述

    循环队列原理及原理图

    但是我们也可以发现,此时的循环队列宏观来看像是front向下移动,一旦循环完一个数组就开始访问第一个元素。可实质上由于front向下移动,访问过的元素又被加进了数组里,一旦加到数组满了,就再扩充数组的容量,然后front继续移动,以前的元素又被加进去…依次继续下去
    在这里插入图片描述

    展开全文
  • Java循环队列.txt

    2020-01-10 21:49:12
    实现了循环队列数据结构的Java语言源代码,为充分利用向量空间,克服"假溢出"现象的方法是:将向量空间想象为一个首尾相接的圆环,并称这种向量为循环向量。存储在其中的队列称为循环队列循环队列是把顺序队列...
  • Java 循环队列的实现

    千次阅读 2019-06-07 19:03:38
    队列概念  队列(Queue)是限定只能在一端插入、另一端删除的线性表。允许删除的一端叫做队头(front),允许插入的一端叫做队尾(rear),没有元素的队列称为“空队列”。  队列具有先进先出(FIFO)的特性。  ...

    队列概念

      队列(Queue)是限定只能在一端插入、另一端删除的线性表。允许删除的一端叫做队头(front),允许插入的一端叫做队尾(rear),没有元素的队列称为“空队列”。

      队列具有先进先出(FIFO)的特性。

      普通顺序队列存在的问题

        在普通顺序队列中,入队的操作就是先将尾指针rear右移一个单位,然后将元素值赋值给rear单位。出队时,则是头指针front后移一个单位。像这样进行了一定数量的入队和出队操作后,可能会出现这样的情况:

        尾指针rear已指到数组的最后有一个元素,即rear==MaxLen-1,此时若再数组的前面部分可能还有很多闲置空间,即这种溢出并非是真的没有可用的存储空间,故称这种溢出现象为“假溢出”。显然,必须要解决这一块假溢出的问题,否则顺序队列就没有太多使用价值。

      循环队列

        循环队列的存储结构,头、尾指针都和普通顺序队列相同。不同的只是将队列视为“环状结构”,即data[0]为紧接着data[MaxLen-1]的单元,为相邻的元素,首位成为一个环。结构如下:(来自:百科)

     

    代码实现

      全局变量:定义队列长度

      

    static int MaxLen;

      循环队列基本数据结构的实现:

    复制代码

    static class myQueue{
                int front;
                int rear;
                int queueList[];
                public myQueue() {
                    // TODO Auto-generated constructor stub    
                    queueList=new int[MaxLen];
                    front=0;
                    rear=0;
                }
    }

    复制代码

      判空函数

    public boolean isEmpty() {
                    if(front==rear){
                    return true;
                }
                    return false;
                }

      判满函数

    复制代码

    public boolean isFull(){
                    if(((rear+1)%MaxLen)==front){
                        return true;
                    }
                    else{
                        return false;
                    }
                }

    复制代码

     取队头元素

     

    复制代码

    public void queueFront(int getFront){
                    if(isEmpty()==false){
                        getFront=queueList[(front+1)%MaxLen];
                    }
                    else {
                        System.out.println("ERROR:Queue is Empty");
                        return;
                    }
                }

    复制代码

    入队

    复制代码

    public void enQueue(int enData) {
                    if(isFull()==false){
                        rear=(rear+1)%MaxLen;
                        this.queueList[rear]=enData;
                    }
                    else{
                        System.out.println("ERROR:Queue is Full");
                        return;
                    }
                    
                }

    复制代码

    出队

    复制代码

    public void outQueue() {
                    if(isEmpty()==false){
                        front=(front+1)%MaxLen;
                    }
                    else {
                        System.out.println("ERROR:Queue is Empty");
                        return;
                    }
                    
                }

    复制代码

     

    作者:Rekent 
    出处:http://www.cnblogs.com/rekent/ 

    展开全文
  • Java循环队列

    千次阅读 2018-01-21 21:36:56
    队列的主要作用是存储数据并且其能保证先进先出,正如排队一样,先进入的先处理 代码 Queue.java ... *循环队列的基本操作 */ public class Queue{ /** * 队头 */ private int front; /** * 队尾 */

    队列的主要作用是存储数据并且其能保证先进先出,正如排队一样,先进入的先处理

    代码

    Queue.java

    package ThreeThree;
    /**
     * 循环顺序队列
     * @author 焦焱-16060211104
     *循环队列的基本操作
     */
    public class Queue{
    /**
     * 队头
     */
    private int front;
    /**
     * 队尾
     */
    private int rear;
    /**
     * 数据
     */
    private Object[] a;
    /**
     * 最大元素数
     */
    private int max;
    /**
     * 当前元素数
     */
    private int num;
    public Queue(int n) {
        a = new Object[n];
        front=0;
        rear=0;
        num=0;
        max = n;
    }
    /**
     * 入队
     * @param data 数据
     */
    public void add(Object data)
    {
         if (num > 0 && front == rear) {
             System.out.println("队列已满");         
        }else {
              a[rear] = data;
              rear=(rear+1)%max;
              num++;
        }
    }
    /**
     * 出队
     * @return 数据
     */
    public Object delete()
    {
        if(num==0)
        {
            System.out.println("队列为空");
            return null;
        }else
        {
            Object o = a[front];
            front=(front+1)%max;
            num--;
            return o;
        }
    }
    /**
     * 返回队列是否为空
     * @return 如果为空返回true
     */
    public boolean isEmpty()
    {
        if(num==0)
            return true;
        else
            return false;
    }
    }
    

    Test.java

    package ThreeThree;
    
    public class Test {
    public static void main(String[] args) {
        Queue T = new Queue(5);
        System.out.println(T.delete());
        T.add(1);
        T.add(2);
        T.add(3);
        T.add(4);
        T.add(5);
        T.add(6); //队满
        System.out.println(T.delete());
        T.add(6);
        System.out.println(T.delete());
        System.out.println(T.delete());
        T.add(5);
        T.add(6);
        System.out.println(T.delete());
        System.out.println(T.delete());
        System.out.println(T.delete());
        System.out.println(T.delete());
        System.out.println(T.delete());
        System.out.println(T.delete());
    }
    }
    

    运行结果

    这里写图片描述

    展开全文
  • JAVA循环队列

    千次阅读 2017-09-15 15:25:44
    一、JAVA 中已经自带了 Queue、DQueue、ArrayList、LinkedList 等常用的数据结构,为什么还要单独实现循环队列? 之所以使用自定义循环队列,出发点还是基于我们在实际应用中对于数据处理各种各样的需求。使用...
  • java循环队列的实现

    千次阅读 2018-11-15 10:33:05
    * 循环队列 * &amp;lt;p&amp;gt; * 注意:判空和判满的两种情况: * 情况1.另设一个标识位区别队列是空还是满 * 情况2.少用一个元素空间,约定以&quot;队列头指针在队尾指针的下一位位置上&...
  • java循环队列的分析和实例介绍.pdf
  • 下面小编就为大家分享一篇java队列实现方法(顺序队列,链式队列,循环队列),具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • java实现循环队列

    2021-03-17 16:21:45
    java实现循环队列循环队列的优点普通队列出队操作开销大:在出队操作时,索引为0后面的所有元素,都需要往前移动一位,元素越多,消耗的时间也越多,时间复杂度为O(N)。循环队列的逻辑:1、当元素较少时(tail位置在...
  • stm32两个串口,一个串口接收子节点的数据,然后同时经另一个串口发送到上位机,即stm32双串口之间通讯,该版本为数据缓存为循环队列版。带有指令解析。函数十分灵活。有不懂的地方可以联系我 E70_Init(); E31_Init...
  • 循环队列实现杨辉三角的输出。通过该程序可以让你对循环队列有一定的理解。
  • Java循环队列的实现

    千次阅读 2018-01-03 10:19:45
    队列是一种特殊的线性表,其特殊性体现在...在实际使用中,由于顺序队列经常会因数组下标越界出现”假溢出“问题,所以除了一些简单应用之外,真正实用的队列是循环队列。 队空状态:  front=rear=0 队满状态: f
  • 622. 设计循环队列 设计你的循环队列实现。 循环队列是一种线性数据结构,其操作表现基于 FIFO(先进先出)原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以...
  • 基于数组的循环队列其实很简单,就是当数组满后重置入队和出队位置到数组头部。 public class CircleQueue<E> { // Object保存E,因为E不能E[] --> (E)obj private Object[] items; private int ...
  • Java数组实现循环队列

    千次阅读 2018-10-29 20:55:01
    Java数组实现循环队列 上一节(Java实现队列——顺序队列、链式队列)我们使用数组实现了顺序队列,但是在tail == n时会有数据搬移操作,这样入队操作性能就会受到影响。这里我们使用循环队列的解决思路。 循环队列 ...
  • 队列作为基础的数据结构,是程序员员的入门课。也是所有程序员必须掌握的一种数据结构,队列在程序中广泛应用,因此我们应该对队列有深入的了解。队列最主要的性质就是FIFO(First ... 首先下面我们用Java中的List...
  • 队列的定义: 队列是一种只允许一端进行插入操作,在另一端进行删除操作的线性表。允许插入的一端称为称为队尾,删除的一段是队头。想象你去排队购买车票时,排着一个很长的队,排在最前面的人买完票走了,这个...
  • 主要的功能:1)循环队列的初始化 2)求循环队列的长度 3)循环队列的插入删除操作 4) 判断循环队列是否为空,是否已经满了 5)遍历循环队列 杨辉三角形
  • Java 队列Queue及循环队列

    千次阅读 2019-04-04 17:45:14
    队列是一种线性结构。 相比数组,队列对应的操作是数组的子集。 只能从一段(队尾)添加元素,只能从另一端(队首取出元素)。 队列的操作: 队列的实现: 添加元素(入队) : void enqueue(E) 删除...
  • 数据结构之循环队列Java实现)

    千次阅读 2018-07-15 13:12:55
    我们假设一个队列有n个元素,则顺序存储的队列需建立一个大于n的数组,并把队列的所有元素存储在数组的前n个单元,数组下标为0的一端即是队头。所谓的入队列操作,其实就是在队尾追加一个元素,不需要移动任何元素,...
  • 基本概念(1)顺序队列(2)循环队列(3)过程实例二.相关属性、方法一.基本概念队列(queue)是一种线性的数据结构,只允许在表的一端进行插入操作而在另一端进行删除的线性表。进行删除操作的一端称为队头,进行插入操作的...
  • 622. 设计循环队列 难度: 中等 题目分析: 看下面代码实现。参考的是裘宗燕的《数据结构与算法:Python语言描述》。此处不建议使用python内置的list的append, pop操作,使用了就违背设计循环队列的初衷:消除...
  • 1. 基于数组实现循环队列 package com.feifei.demo.queue; import java.io.Serializable; import java.util.Objects; import java.util.stream.Stream; /** * 自定义循环队列 * 1. 单队列会出现假溢出的情况,...
  • NULL 博文链接:https://128kj.iteye.com/blog/1624362

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 182,386
精华内容 72,954
关键字:

java循环队列

java 订阅
友情链接: Qt串口12313123123.zip