Cola de simulación de matriz Java

Cola

Primero en entrar, primero en salir

A que te refieres
Entiendo: la cola es una matriz (sin incluir una lista vinculada), y luego aplicamos una regla para almacenar y recuperar datos
cuando solo se permite almacenar datos de un extremo, y una matriz para recuperar datos del otro extremo es la cola, lo que debemos hacer Es imponer nuestras reglas en esta matriz

Si no lo entiende, el diagrama anterior

ilustra los pasos:
[Figura (a)] Hay una matriz con una longitud de 5, defina el logotipo de la cabeza y el logotipo de la cola
[Figura (b)] Inserte los datos e1, e2, e3 en orden e inserte los datos de la cola En este momento, el logotipo de la cabeza permanece sin cambios, inserte un dato, el logotipo de la cola aumentará en 1
[figura (c)]. El elemento solo puede extraerse de la cabeza, y cada vez que toma datos, el logotipo de la cabeza aumenta en uno
[figura (d) 】 Esto crea una regla de primero en
entrar, primero en salir. Si no entiende, piense más, escriba el código dos veces o hable con otros.

Implementación de código

public class ArrayQueue {
    //最大长度
    int maxSize;
    //定义一个数组，存储数据
    private int[] queue;
    //定义对头和队尾标志
    private int front;
    private int rear;
    //初始化一个数组
    public void init(int maxSize){
        front = -1;
        rear = -1;
        this.maxSize = maxSize;
        this.queue = new int[maxSize];
    }
    //判断对满
    public boolean isFull(){
         return rear == maxSize-1;
    }
    //判断队空
    public boolean isEnpty(){
        return front == rear;
    }
    //加入数据，只能从队头加入
    public void add(int num){
        if(isFull()){
            System.out.println("队列满了,插入失败");
            return;
        }
        //要理清楚先后顺序
        rear++;
        queue[rear] = num;
    }
    //取数据，只能从队尾取
    public int get(){
        if(isEnpty()){
            System.out.println("队列为空");
            //数组初始化之后默认值就是0
            return 0;
        }
        front++;
        return queue[front];
    }
    //查看队头元素
    public int showFront(){
        if(isEnpty()){
            System.out.println("队列为空");
            //数组初始化之后默认值就是0
            return 0;
        }
        return queue[front+1];
    }
    //遍历所有数
    public void showAll(){
        if(isEnpty()){
            System.out.println("队列为空");
            //数组初始化之后默认值就是0
            return;
        }
        System.out.println("显示队列：======");
        for(int i = front+1; i <= rear; i++){
            System.out.println(queue[i]);
        }
        System.out.println("===============");
    }
}

[Mejora de código]
Al usar esta cola, se sentirá incómodo, porque define su longitud, su longitud no se puede cambiar, podemos diseñar una cola que puede aumentar en longitud

[Idea de diseño]
Cuando rear == maxSize, es decir, cuando la matriz está llena, creamos una nueva matriz, que es dos veces más larga que la matriz original, y luego asignamos el valor de la matriz original a la nueva matriz

[Implementación del código]
Solo necesitamos modificar el código del método add

public void add(int num){
    if(isFull()){
        //新建一个长度为原来两倍的数组
        int[] newQueue = new int[maxSize*2];
        //原数组赋值到新数组
        for(int i = front+1; i <= rear; i++){
            newQueue[i] = queue[i];
        }
        rear++;
        queue[rear] = num;
        return;
    }
    rear++;
    queue[rear] = num;
}

[Pensamiento]
De hecho, todavía hay mucho margen de mejora en el código
1. Por ejemplo, aquí hemos escrito una matriz que solo puede usar int type, entonces ¿podemos hacer que el tipo sea un parámetro y confirmarlo al inicializar la cola? El conocimiento genérico se puede usar aquí
2. Por ejemplo, cuando se obtienen datos, cuando este número no existe, devolvemos el valor predeterminado de 0. ¿Podemos devolver 0, puede el código terminar normalmente, las excepciones se pueden usar aquí Conocimiento

Mejora de la estructura de datos
Descubriremos que si esta estructura se utiliza para crear una cola, después de extraer los datos, el espacio en frente del frente no se puede operar, lo que resulta en una gran cantidad de espacio desperdiciado. En este momento, podemos
imaginar la cola secuencial como un anillo