java-->队列(基础)


java-->队列(基础)_第1张图片

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

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

java-->队列(基础)_第2张图片

队列本身是有序列表,如果使用数组的结构来存储队列的数据,则队列数组的声明如下图,其中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==================================

你可能感兴趣的:(数据结构,java,开发语言)