精华内容
下载资源
问答
  • 主要介绍了Java数据结构循环队列简单定义与用法,简要描述了循环队列的概念、原理,并结合实例形式分析了java循环队列的定义与使用方法,需要的朋友可以参考下
  • JAVA数据结构循环队列的实现

    千次阅读 2017-07-07 11:18:03
    1、循环队列CircleQueue类的实现代码如下所示: public class CircleQueue { private Object[] array; private int capacity;//队列容量 private int count;//队列中元素的个数 private int front; private ...

    1、循环队列CircleQueue类的实现代码如下所示:

    public class CircleQueue {
    	private Object[] array;
    	private int capacity;//队列容量
    	private int count;//队列中元素的个数
    	private int front;
    	private int rear;
    	
    	public CircleQueue(int capacity){
    		this.capacity = capacity;
    		array = new Object[capacity];
    		count = 0;
    		front = 0;
    		rear = 0;
    	}
    	
    	//入队
    	public boolean append(Object data){
    		boolean ret = (array != null) && (capacity > 0);
    		
    		if(ret){
    			array[rear] = data;
    			rear = (rear + 1) % capacity;
    			
    			count++;
    			
    			if(count > capacity){
    				count = capacity;
    			}
    		}
    		
    		return ret;
    	}
    	
    	//出队
    	public Object retrieve(){
    		Object data = null;
    		
    		if((array != null) && (capacity > 0) && (count > 0)){
    			data = array[front];
    			array[front] = null;
    			front = (front + 1) % capacity;
    			count--;
    		}
    		
    		return data;
    	}
    	
    	//获取队列中元素的个数
    	public int getCount(){
    		return count;
    	}
    	
    	//获取队列的容量
    	public int getCapacity(){
    		return capacity;
    	}
    	
    	//查看队头的数据,只查看,不删除。
    	public Object getHead(){
    		Object ret = null;
    		
    		if(array != null && capacity > 0 && count > 0){
    			ret = array[front];
    		}
    		
    		return ret;
    	}
    	
    	public boolean isEmpty(){
    		return count == 0;
    	}
    	
    	//清空队列中的元素
    	public void clear(){
    		array = null;
    		array = new Object[capacity];
    		count = 0;
    		front = 0;
    		rear = 0;
    	}
    	
    	public void destroy(){
    		array = null;
    		count = 0;
    		front = 0;
    		rear = 0;
    	}
    }
    2、测试类Test的实现代码如下所示:

    public class Test {
    
    	public static void main(String[] args) {
    		CircleQueue queue = new CircleQueue(5);
    		queue.append("元素1");
    		queue.append("元素2");
    		queue.append("元素3");
    		queue.append("元素4");
    		queue.append("元素5");
    		queue.append("元素6");
    		queue.append("元素7");
    		
    		System.out.println("队列的容量:"+queue.getCapacity());
    		System.out.println("队列中元素的个数:"+queue.getCount());
    		System.out.println("队列是否为空?"+queue.isEmpty());
    		System.out.println("队头元素:"+queue.getHead());
    		System.out.println("出队:");
    		
    		while(!queue.isEmpty()){
    			System.out.print(queue.retrieve()+"  ");
    		}
    		
    		queue.clear();
    		System.out.println("\n\n队列的容量:"+queue.getCapacity());
    		System.out.println("队列中元素的个数:"+queue.getCount());
    		System.out.println("队列是否为空?"+queue.isEmpty());
    		
    		queue.destroy();
    	}
    }



    展开全文
  • 基于数组的循环队列其实很简单,就是当数组满后重置入队和出队位置到数组头部。 public class CircleQueue<E> { // Object保存E,因为E不能E[] --> (E)obj private Object[] items; private int ...

    1.顺序队列(循环)

    基于数组的循环队列其实很简单,就是当数组满后重置入队出队位置到数组头部。

    public class CircleQueue<E> {
    	
        // Object保存E,因为E不能E[] --> (E)obj
        private Object[] items;
        private int putIdx; // 实际入队位置
        private int takeIdx; // 实际出队位置
        private int count; // 队列中元素打小,注:队列的容量在数组初始化后就不再改变
    	
    	// 指定容量初始化
        public CircleQueue(int size) {
            this.items = new Object[size];
            this.count = 0;
            this.putIdx = 0;
            this.takeIdx = 0;
        }
    	
        public boolean enqueue(E e) {
            // 满了就返回
            if (count == items.length)  return false;
            // 放入
            items[putIdx] = e;
            // 在放入后更新下一次入队的位置putIdx(++)
            // 若putIdx到了数组最后一个元素,就归0
            if (++putIdx == items.length) putIdx = 0;
            count++;
    
            return true;
        }
    
        public E dequeue() {
        	// 队列为空返回null
            if (count == 0) return null;
            E res = (E) items[takeIdx];
            // 在取出后,更新下一次取出位置takeIdx(++)
            // 若takeIdx到了数组最后一个元素,就归0
            if (++takeIdx == items.length) takeIdx = 0;
            count--;
            return res;
        }
    
        public E peek() {
        	// 注意要非空判断
            return count == 0 ? null : (E)items[takeIdx];
        }
    }
    

    2.链式队列

    在看代码之前,先注意几个非空判断:

    • 可以判断队列为空的条件:
      • head = null
      • tail = null
      • head = tail = null
    • 入队/出队时需要的非空判断:
      • enqueue(入队):若为空 tail = head = node
      • dequeue(出队)
        • 出队前空:return null
        • 出队后空:tail = head = null
    public class LinkedQueue<E> {
    
        class Node<E> {
            E item;
            Node<E> next;
    
            public Node(E e) {
                this.item = e;
            }
        }
    
        private Node head; // 队首
        private Node tail; // 队尾
    
        public LinkedQueue() {
        	// 队列为空时 head = tail = null
            head = tail = null; 
        }
    	
        public void enqueue(E e) {
            Node node = new Node(e);
    		
            // 队列为空
            if(tail == null) {
                head = tail = node;
            }else {
                tail.next = node;
                tail = node;
            }
        }
    
        public E dequeue() {
            // 出队前为空
            if (head == null) {
                return null;
            }
            E item = (E)head.item;
            
            // 出队后空
            if (head.next == null) {
                head = tail = null;
            } else {
            	head = head.next;
            }
            return item;
        }
    
        public E peek() {
            return this.head == null ? null : (E)this.head.item;
        }
    }
    

    从上面代码不难看出,链式队列其实就是链表的基本操作,所以LinkedList也是Queue的一个实现,这块的更多细节可以参考【Java容器源码】LinkedList源码分析

    展开全文
  • 数据结构循环队列Java实现

    千次阅读 2016-10-26 12:12:58
    顺序队列实行先进先出的原则,需要加上front和rear两个变量分别指示队首和队尾在数组中的位置,初值为0。 在非空队列中,front指向队首元素,rear指向队尾元素的下一个存储位置。 由于顺序队列中会产生假溢出的...

    顺序队列实行先进先出的原则,需要加上front和rear两个变量分别指示队首和队尾在数组中的位置,初值为0。

    在非空队列中,front指向队首元素,rear指向队尾元素的下一个存储位置。


    由于顺序队列中会产生假溢出的情形,例如一个有6个存储空间的队列存满,并且出队2次之后,

    我们无法在第七个存储空间继续入队,但实际上此队列在前方仍然有两个空余的存储空间。


    解决这个问题,最好的办法就是将顺序队列看成是一个逻辑上首位相连的循环队列,

    转换可以用rear=(rear+1)%maxSize来实现。


    在循环队列中会有一个问题:无法区分队空和队满的状态,因为队空和队满的条件都是rear==front。


    解决方法有少用一个存储单元,设置一个标志变量,设置一个计数器3种方法,

    这里我们使用少用一个存储单元,即队空的条件为rear==front, 队满的条件为front=(rear+1)%maxSize。


    实现代码如下:

    接口:

    package queueTest;
    
    public interface IQueue {
    	public void clear();
    
    	public boolean isEmpty();
    
    	public int length();
    
    	public Object peek();// 取队首元素
    
    	public void offer(Object x) throws Exception;// 入队
    
    	public Object poll();// 出队
    
    	public void display();
    }
    

    循环队列:

    package queueTest;
    
    public class CircleSqQueue implements IQueue {
    
    	private Object[] queueElem;//队列存储空间
    	private int front;//队首引用,若队列不为空,指向队首元素
    	private int rear;//队尾引用,若队列不为空,指向队尾的下一个元素
    	
    	public CircleSqQueue(int maxsize) {
    		front=rear=0;
    		queueElem=new Object[maxsize];//分配maxsize个单元
    	}
    
    	@Override
    	public void clear() {
    		front=rear=0;
    	}
    
    	@Override
    	public boolean isEmpty() {
    		return rear==front;
    	}
    
    	@Override
    	public int length() {
    		return (rear-front+queueElem.length)%queueElem.length;
    	}
    
    	@Override
    	public Object peek() {
    		if(front==rear){
    			return null;
    		}
    		else{
    			return queueElem[front];
    		}
    	}
    
    	@Override
    	public void offer(Object x) throws Exception {
    		if((rear+1)%queueElem.length==front){//队满
    			throw new Exception("队列已满");
    		}
    		else{
    			queueElem[rear]=x;
    			rear=(rear+1)%queueElem.length;//修改队尾指针
    		}
    	}
    
    	@Override
    	public Object poll() {
    		if(front==rear){
    			return null;//队列为空
    		}
    		else{
    			Object t=queueElem[front];
    			front=(front+1)%queueElem.length;
    			return t;
    		}
    	}
    
    	@Override
    	public void display() {
    		if(!isEmpty()){
    			for(int i=front;i!=rear;i=(i+1)%queueElem.length){
    				System.out.println(queueElem[i].toString()+" ");
    			}
    		}
    		else{
    			System.out.println("此队列为空");
    		}
    	}
    
    }
    


    展开全文
  • 主要介绍了java数据结构与算法之双向循环队列的数组实现方法,结合实例形式分析了双向循环队列的原理与数组实现技巧,并附带说明了该算法的用途,需要的朋友可以参考下
  • 图解Java数据结构队列

    千次阅读 2019-08-06 16:00:07
    本篇文章,将对队列进行一个深入的解析。 使用场景 队列在日常生活中十分常见,...刚才通过生活中的例子大致了解了一下队列,那么从数据结构的角度来讲,队列到底是什么呢? 队列是一个有序列表,可以用数组或是...

    本篇文章,将对队列进行一个深入的解析。

    使用场景

    队列在日常生活中十分常见,例如:银行排队办理业务、食堂排队打饭等等,这些都是队列的应用。那么队列有什么特点呢?
    我们知道排队的原则就是先来后到,排在前面的人就可以优先办理业务,那么队列也一样,队列遵循先进先出的原则。

    队列介绍

    刚才通过生活中的例子大致了解了一下队列,那么从数据结构的角度来讲,队列到底是什么呢?

    • 队列是一个有序列表,可以用数组或是链表来实现
    • 遵循先进先出的原则,即:先存入队列的数据,先取出;后存入队列的数据,后取出
    数组模拟队列

    刚才说到,队列可以用数组或是链表来实现。
    那我们先来看看用数组如何模拟队列?
    在这里插入图片描述
    队列本身是有序列表,若使用数组的结构来存储队列的数据,则队列数组的声明如上图,其中MaxSize是该队列的最大容量。
    因为队列的输出、输入是分别从前后端来处理的,因此需要两个变量front和rear分别记录队列前后端的下标,如上图所示,front会随着数据的输出改变;而rear则是随着数据的输入改变。
    继续深入分析:

    • 当我们将数据存入队列时,称为"addQueue",addQueue的处理需要有两个步骤:
      a)将尾指针往后移:rear + 1
      b)若尾指针rear小于队列的最大下标MaxSize - 1,则将数据存入rear所指的数组元素中,否则无法存入数据。rear == MaxSize - 1 时,表示队列已满

    分析过后,我们用代码来实现数组模拟队列:

    //使用数组模拟队列——编写一个ArrayQueue类
    class ArrayQueue {
    	private int maxSize; // 表示数组的最大容量
    	private int front; // 队列头
    	private int rear; // 队列尾
    	private int[] arr; // 该数组用于存放数据
    
    	// 创建队列的构造器
    	public ArrayQueue(int maxSize) {
    		this.maxSize = maxSize;
    		arr = new int[maxSize];
    		front = -1; // 指向队列头部(指向的是队列头的前一个位置)
    		rear = -1;// 指向队列尾部(指向的是队列尾的数据)
    	}
    
    	// 判断队列是否满
    	public boolean isFull() {
    		return rear == maxSize - 1;
    	}
    
    	// 判断队列是否为空
    	public boolean isEmpty() {
    		return rear == front;
    	}
    
    	// 添加数据到队列
    	public void addQueue(int n) {
    		// 判断队列是否满
    		if (isFull()) {
    			System.out.println("队列满,不能加入数据");
    			return;
    		}
    		rear++;// 让rear后移
    		arr[rear] = n;
    	}
    
    	// 获取队列的数据
    	public int getQueue() {
    		// 判断队列是否空
    		if (isEmpty()) {
    			// 抛出异常
    			throw new RuntimeException("队列空,不能取出数据");
    		}
    		front++;// 让front后移
    		return arr[front];
    	}
    
    	// 显示队列的所有数据
    	public void showQueue() {
    		// 遍历
    		if (isEmpty()) {
    			System.out.println("队列为空");
    			return;
    		}
    		for (int i : arr) {
    			System.out.printf("%d\t", i);
    		}
    	}
    }
    

    经过分析后再来编写代码,会觉得非常简单,现在一个数组模拟的队列就编写完成了。接下来编写测试代码:

    public static void main(String[] args) {
    		// 创建一个队列
    		ArrayQueue arrayQueue = new ArrayQueue(3);
    		int key;// 接收用户输入
    		Scanner sc = new Scanner(System.in);
    		boolean loop = true;
    		// 输出一个菜单
    		while (loop) {
    			System.out.println();
    			System.out.println("1:显示队列");
    			System.out.println("2:添加数据到队列");
    			System.out.println("3:从队列获取数据");
    			key = sc.nextInt();// 接收一个字符
    			switch (key) {
    			case 1:
    				arrayQueue.showQueue();
    				break;
    			case 2:
    				System.out.println("输入一个数:");
    				int value = sc.nextInt();
    				arrayQueue.addQueue(value);
    				break;
    			case 3:
    				try {
    					int res = arrayQueue.getQueue();
    					System.out.println("取出的数据是:" + res);
    				} catch (Exception e) {
    					System.out.println(e.getMessage());
    				}
    				break;
    			}
    		}
    	}
    

    运行效果如下:
    在这里插入图片描述
    但是,这个程序有一个很大的问题,就是当你把队列中的元素取出来之后,再添加发现添加不了,一直提示队列为空,因为此时指向队列前后端的两个变量相等,而判断队列是否为空就是依靠这两个变量来判断的。

    数组模拟环形队列

    刚才我们说到这个程序是有问题的,数组只能使用一次,那我们可以对前面的数组模拟队列进行优化,为了能够充分利用数组,我们可将数组看成是一个环形的。
    我们先来分析一下(还是看这张图):
    在这里插入图片描述

    1. 首先我们将front的含义做一个调整:front就指向队列的第一个元素,也就是说arr[front]就是队列的第一个元素,front的初始值为0
    2. 将rear的含义也做一个调整:rear指向队列的最后一个元素的后一个位置,这样调整的目的是希望空出一个空间作为一个约定,rear的初始值也为0
    3. 当队列满时,条件是(rear + 1) % MaxSize == front,那么条件依据是什么呢?我们举个例子,假设现在rear指向的是数组的倒数第二个元素,因为我们要预留出一个空间,所以此时队列应该就是满的,而事实上倒数第二个元素的下标加1然后取模MaxSize确实等于front,因为此时的front为0,就证明该队列已满
    4. 当队列空时,条件是rear == front

    那么如果按照上面的分析实现,队列中的有效元素个数即为:(rear + MaxSize - front) % MaxSize。
    接下来在原来的代码上进行一个优化:

    public class CircleArrayQueueDemo {
    
    	public static void main(String[] args) {
    		// 创建一个队列
    		CircleArrayQueue arrayQueue = new CircleArrayQueue(3);
    		int key;// 接收用户输入
    		Scanner sc = new Scanner(System.in);
    		boolean loop = true;
    		// 输出一个菜单
    		while (loop) {
    			System.out.println();
    			System.out.println("1:显示队列");
    			System.out.println("2:添加数据到队列");
    			System.out.println("3:从队列获取数据");
    			key = sc.nextInt();// 接收一个字符
    			switch (key) {
    			case 1:
    				arrayQueue.showQueue();
    				break;
    			case 2:
    				System.out.println("输入一个数:");
    				int value = sc.nextInt();
    				arrayQueue.addQueue(value);
    				break;
    			case 3:
    				try {
    					int res = arrayQueue.getQueue();
    					System.out.println("取出的数据是:" + res);
    				} catch (Exception e) {
    					System.out.println(e.getMessage());
    				}
    				break;
    			}
    		}
    	}
    }
    
    //使用数组模拟队列——编写一个ArrayQueue类
    class CircleArrayQueue {
    	private int maxSize; // 表示数组的最大容量
    	private int front; // 队列的第一个元素
    	private int rear; // 队列的最后一个元素的后一个位置
    	private int[] arr; // 该数组用于存放数据
    
    	// 创建队列的构造器
    	public CircleArrayQueue(int maxSize) {
    		this.maxSize = maxSize;
    		arr = new int[maxSize];
    	}
    
    	// 判断队列是否满
    	public boolean isFull() {
    		return (rear + 1) % maxSize == front;
    	}
    
    	// 判断队列是否为空
    	public boolean isEmpty() {
    		return rear == front;
    	}
    
    	// 添加数据到队列
    	public void addQueue(int n) {
    		// 判断队列是否满
    		if (isFull()) {
    			System.out.println("队列满,不能加入数据");
    			return;
    		}
    		// 直接将数据加入
    		arr[rear] = n;
    		rear = (rear + 1) % maxSize;// 将rear后移,必须考虑取模(当rear指向最后时,可以通过取模将rear指向队列起始位置)
    	}
    
    	// 获取队列的数据
    	public int getQueue() {
    		// 判断队列是否空
    		if (isEmpty()) {
    			// 抛出异常
    			throw new RuntimeException("队列空,不能取出数据");
    		}
    		// 需要分析出front是指向队列的第一个元素
    		// 1、先把front对应的值保存到一个临时变量中
    		int value = arr[front];
    		// 2、将front后移,考虑取模
    		front = (front + 1) % maxSize;
    		// 3、将临时保存的变量返回
    		return value;
    	}
    
    	// 显示队列的所有数据
    	public void showQueue() {
    		// 遍历
    		if (isEmpty()) {
    			System.out.println("队列为空");
    			return;
    		}
    		// 从front开始遍历
    		for (int i = front; i < front + size(); i++) {
    			System.out.printf("%d\t", arr[i % maxSize]);
    		}
    	}
    
    	// 求出当前队列有效数据个数
    	public int size() {
    		return (rear + maxSize - front) % maxSize;
    	}
    }
    

    运行效果如下:
    在这里插入图片描述
    现在我们就能够循环利用这个队列了。

    推荐阅读

    1.图解Java数据结构之稀疏数组

    2.图解Java数据结构之单链表

    3.图解Java数据结构之双向链表

    4.图解Java数据结构之环形链表

    展开全文
  • 队列也很简单,需要注意的是判断队列上溢和下溢的情况,以及队列指针循环的情况。 代码演示:
  • Java数据结构队列

    2019-05-15 10:07:11
    基本概念 队列是一种特殊的线性表,其...队列具有FIFO(先进先出)的特点,队列的底层数据结构可以用数组来实现。 队列的抽象数据类型 package ch03; public interface IQueue { public void clear(); pu...
  • 数据结构--java语言实现循环队列

    千次阅读 2019-05-24 22:29:42
    循环队列是一种线性数据结构,其操作表现基于 FIFO(先进先出)原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通...
  • 队列与栈不同的是:栈是“先进后出,后进先出”,而队列是“先进先出”;可以讲队列看作是一个水管,一头进,另外一头出.... 同样这个很简单,话不多说直接上代码案例,一看你就懂了 public class MyQueue { // ...
  • JAVA数据结构——队列(二)

    千次阅读 2020-01-17 20:27:59
    根据上篇文章JAVA数据结构——队列我们留一下一个问题,如何利用队列解决素数环问题,下面我来讲解一下思路: 1. 先映入顺序表类Sqlist 和 链队列类 LinkQueue ,在创建Sqlist类的一个对象L作为顺序表,用于存放素数...
  • Java代码实现循环队列

    2021-09-26 21:21:41
    循环队列结构 Java代码实现循环队列 // 基于数组实现一个循环链表 public class CircleArrayQueue<T> { // 定义数组用于存放数据 private T[] arr; private int head; // 记录队列头 private int tail; ...
  • 循环队列是一种线性数据结构,其操作表现基于 FIFO(先进先出)原则并且队尾被连接在队首之后以形成一个循环, 它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通...
  • Java实现简单队列、循环队列操作1.简单队列package queue; import java.util.Scanner; /** * 队列节点 * @author wsz * @date 2018年1月18日 */ class Node{ String name; int age; } /** * 队列 * @author...
  • Queue循环队列详解以及代码实现 Queue循环队列学习目标 1. 基本介绍 2. 特点和存储方式 3. 比较单向队列 4. 数组模拟队列代码实现 5. 总结重点 一,基本介绍 循环队列可以看成一个环形的数组 二,特点和存储方式 ...
  • Java数组实现循环队列

    千次阅读 2019-09-27 15:32:26
    Java数组实现循环队列
  • Java编写一个循环队列
  • JAVA循环队列

    千次阅读 2017-09-15 15:25:44
    一、JAVA 中已经自带了 Queue、DQueue、ArrayList、LinkedList 等常用的数据结构,为什么还要单独实现循环队列? 之所以使用自定义循环队列,出发点还是基于我们在实际应用中对于数据处理各种各样的需求。使用...
  • 1. 数据结构和算法(一)Java实现循环队列 1.1 什么是循环队列   循环队列:具有队头指针(front)和队尾指针(rear),指示队列元素所在的位置,避免删除元素时移动大量元素。队列也是一种线性表,只不过它是操作...
  • 数据结构循环队列Java实现)

    千次阅读 2018-07-15 13:12:55
    我们假设一个队列有n个元素,则顺序存储的队列需建立一个大于n的数组,并把队列的所有元素存储在数组的前n个单元,数组下标为0的一端即是队头。所谓的入队列操作,其实就是在队尾追加一个元素,不需要移动任何元素,...
  • Java循环队列.txt

    2020-01-10 21:49:12
    实现了循环队列数据结构Java语言源代码,为充分利用向量空间,克服"假溢出"现象的方法是:将向量空间想象为一个首尾相接的圆环,并称这种向量为循环向量。存储在其中的队列称为循环队列循环队列是把顺序队列...
  • 队列作为基础的数据结构,是程序员员的入门课。也是所有程序员必须掌握的一种数据结构队列在程序中广泛应用,因此我们应该对队列有深入的了解。队列最主要的性质就是FIFO(First In First Out)先进先出,也就是说...
  • 学习了队列,就不得不知道一些特殊的队列,在实际应用中,这些队列有时用的更多,此为循环顺序队列 循环顺序队列就是为了防止出现假溢出现象而出现的,其功能类似于一个环形,如图,但实际上还是一个线性存储的结构
  • import java.util.Arrays; public class LoopQueue { private int DEFAULT_SIZE = 10;... // 用于保存循环队列的数组 private Object[] elementData; // 循环队列中的首元素 private int front; /
  • Java笔试面试-数据结构队列

    万次阅读 多人点赞 2019-09-18 09:04:13
      与栈相对的一种数据结构, 集合(Collection)的一个子类。队列允许在一端进行插入操作,而在另一端进行删除操作的线性表,栈的特点是后进先出,而队列的特点是先进先出。队列的用处很大,比如实现消息队列。...
  • java数据结构之线性队列的实现

    千次阅读 2016-06-03 21:38:55
    今天介绍一下数据结构中的线性队列以及线性队列中的缺点,和改善线性队列循环线性队列操作。 队列的定义: 队列(Queue)是只允许在一端进行插入,而在另一端进行删除的运算受限的线性表。 (1)允许...
  • 队列是一种线性的数据结构【线性数据结构:数组、栈、队列】 相比数组,队列对应的数据操作是数组的子集。 只能从一端(队尾)添加元素,只能从另一端(队首)取出元素。   数组队列 代码实现 Array数组类 ...
  • 与栈相似,队列也是顺序存储元素的线性数据结构,但队列是先进先出。 操作 插入:put,add,enque 删除:delete,get,deque 插入数据项的队尾:back,tail,end 移除数据项的队头:head 查看:peek,返回队头数据项的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 92,919
精华内容 37,167
关键字:

java数据结构循环队列

java 订阅
数据结构 订阅