java--＞队列（基础）

🐾😆🐾😆🐾🐾😆🐾😆🐾🐾😆🐾🐾😆🐾🐾😆🐾🐾😆🐾🐾🐾🐾🐾🐾🐾🐾😆

队列是一个有序列表，可以用数组或者是链表来实现。
遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出。
下面是使用数组来模你队列的示意图：（图有点糊嘿嘿嘿~）

可以看出有两个指针，会随着数据的增加和减少而移动。
rear指针：尾指针；front：头指针。
加数据尾部指针移动。说明这是后来的在后面。
去掉数据首部移动，说明先在头部去除。

队列本身是有序列表，如果使用数组的结构来存储队列的数据，则队列数组的声明如下图，其中maxSize是该队列的最大容量。
因为队列的输出，输入数分别从前后端来处理，因此需要两个变量front及rear分别记录队列前后端的下标，front会随着数据输出而改变，而rear则是随着数据输入而改变。就像上图一样。

数组模拟队列👅👅👅

当我们将数据存入队列时称为“addQueue”,添加数据有两个步骤：
1）：将尾指针往后移动，rear+1，当front == rear就说明队列为【空】
2）：若尾指针rear小于队列的最大下标maxSize-1，则将数据存入rear所指的数组元素中，否则无法存入数据。rear==maxSize-1【因为队列满了】

package a_heima.queue;

import java.util.Scanner;

/**
 * @ClassName MyQueue
 * @Description TODO 先进先出
 * @Author zyhh
 * @date 2023/12/28 14:18
 * @version: 1.0
 */
public class MyQueue {
    public static void main(String[] args) {
        ArrayQueue arr = new ArrayQueue(3);
        arr.addQueue(1);
        arr.addQueue(2);
        arr.addQueue(3);
        System.out.println("=====显示队列所有数据===");
        arr.showQueue();
        System.out.println("====队列满的时候看看是否还能再加入===");
        arr.addQueue(4);
        System.out.println("====查看队列是否为空===");
        System.out.println(arr.isEmpty());
        System.out.println("====查看第一个数据===");
        System.out.println(arr.peekHeader());
        System.out.println("====从队列中删除数据并能并返回===");
        int i = arr.delQueue();
        System.out.println(i);
        System.out.println("====从队列中删除数据并能并返回===");
        int i1 = arr.delQueue();
        System.out.println(i1);
        System.out.println("=====显示队列所有数据===");
        arr.showQueue();
    }


}
//数据模你队列
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 value){
//        判断队列是否满
        if(isFull()){
            System.out.println("队列满了，不能添加数据！");
            return;
        }
        rear++;
        arr[rear]=value;
    }
//    从队列中删除并返回数据
    public int delQueue(){
//        判断队列是否是空
        if(isEmpty()){
//            System.out.println("对列为空，无法取数据。");
//            return;
            throw new RuntimeException("队列为空，无法获取数据");
        }
        front++;
        return arr[front];
    }
//    显示队列所有数据
    public void showQueue(){
        if(isEmpty()){
            System.out.println("队列为空");
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
//    显示队列的头数据
    public int peekHeader(){
        if(isEmpty()){
            throw new RuntimeException("空队列，没有数据");
        }
        return arr[front+1];
    }
}

上面就是数组队列，这种队列的弊端就是，就如我们取出数据，根据先进先出的特点，数据是从头部进行删除的。删除之后这个位置就不能再用了啊，这多浪费。反正添加数据肯定不是加在前面的，那前面的arr[0],arr[1]位置数据被取出来中止呕怒就浪费空间了吗。

就上面的问题，我们有一个叫做环形队列的东西。
你可以形象的想象一下，如果我们在后面添加数据，取出数据的时候前面的位置是空，但因为这个队列是环形的，所以不就可以在一定条件下可以向某些位置添加数据了吗~~⭐️⭐️⭐️

环形队列💥💥💥

思路：

1）：把front含义做个调整，现在让front指向数组的第一个元素，front初始值为0。也就是说arr[front]指向第一个元素。【上面队列我们是让front指向队列第一个数据的前一个位置。】
2）：把rear含义调整为，指向队列最后一个元素的后一个位置,rear初始值为0。因为希望空出一个空间作为约定。【上面是rear指向了最后一个元素。】。因为总是空出一个位置，所以实际容量是定义的容量-1.
3）：当队列满时，条件是(rear+1)%maxSize==front表示满了。
4：队列为空的条件：rear==front。
5）：队列中有效的数据个数(rear+maxSize-front)%maxSize。
6）：我们就可以在原来的队列上修改的到一个环形队列。

环形链表代码实现：
···java
package a_heima.queue;

/**

• @ClassName LoopQueue

• @Description TODO 环形队列

• @Author zyhh

• @date 2024/1/3 10:57

• @version: 1.0
  */
  public class MyCircleQueue {
  public static void main(String[] args) {
  CircleQueue circleQueue = new CircleQueue(5);
  circleQueue.addQueue(1);
  circleQueue.addQueue(2);
  circleQueue.addQueue(3);
  circleQueue.addQueue(4);
  circleQueue.addQueue(5);
  // circleQueue.addQueue(6);
  System.out.println(“显示所有数据=”);
  circleQueue.showQueue();
  System.out.println(“查看头数据========”);
  System.out.println(circleQueue.peekHeader());
  System.out.println(“=取出并删除队列数据=”);
  System.out.println(circleQueue.delQueue());
  System.out.println(“显示所有数据=”);
  circleQueue.showQueue();
  System.out.println(“添加数据后再显示所有数据=”);
  circleQueue.addQueue(4);
  circleQueue.addQueue(5);
  circleQueue.showQueue();
  System.out.println(“添加数据后再显示所有数据=”);
  System.out.println(“删除一下：：”+circleQueue.delQueue());
  circleQueue.addQueue(6);
  circleQueue.showQueue();

  }
  }
  //数据模拟队列
  class CircleQueue{
  private int maxSize;//数组容量。
  private int front;//头指针,指向队列的第一个数据。
  private int rear;//尾指针，指向队列尾最后一个的后一个位置。
  private int[] arr;//用于存放数据，模拟队列。

  public CircleQueue(int maxSize) {
  this.maxSize = maxSize;
  arr=new int[maxSize];
  front=0;
  rear=0;
  }
  // 判断队列是否满
  public Boolean isFull(){
  return (rear+1)%maxSize== front;
  }
  // 判断队列是否为空
  public Boolean isEmpty(){
  return rear==front;
  }
  // 添加数据到队列
  public void addQueue(int value){
  // 判断队列是否满
  if(isFull()){
  System.out.println(“队列满了，不能添加数据！”);
  return;
  }
  arr[rear]=value;
  rear++;
  rear=(rear)%maxSize;//取模就是为了防止恰好转了一圈rear数据超过环形数组长度
  }

  // 显示队列所有数据
  public void showQueue(){
  if(isEmpty()){
  System.out.println(“队列为空”);
  return;
  }
  // int value=arr[front];
  int a=front;
  while(true){
  System.out.println(arr[front % maxSize]);
  front++;
  if(front%maxSize==rear){
  break;
  }
  }
  front=a;
  }
  // 显示队列的头数据
  public int peekHeader(){
  if(isEmpty()){
  throw new RuntimeException(“空队列，没有数据”);
  }
  return arr[front];
  }
  // 从队列中删除并返回数据
  public int delQueue(){
  // 判断队列是否是空
  if(isEmpty()){
  // System.out.println(“对列为空，无法取数据。”);
  // return;
  throw new RuntimeException(“队列为空，无法获取数据”);
  }
  int value=arr[front];
  front++;
  front=front%maxSize;
  return value;
  }
  }

···

================================== over==================================