Explicar la estructura de datos de una manera sencilla-cola

cola

concepto

Cola: una tabla lineal especial que solo permite insertar datos en un extremo y eliminar datos en el otro extremo. La cola tiene FIFO (Primero en entrar, primero en salir) en la cola: el final de la operación de inserción se llama Cola / Posterior) la cola: el final de la operación de eliminación se denomina cabeza de la cola (Head / Front)

Relación de interfaz

Descripción del método

método	Lanzar una excepción	Devolver valor especial
Poner en cola	añadir (e)	oferta (e)
Dequeue	recordar ()	encuesta()
Elemento líder	elemento()	ojeada()

Realización del método

class Node {
    
    
    public int val;
    public Node next;

    public Node(int val) {
    
    
        this.val = val;
    }
}

public class MyQueue {
    
    
    public Node first;
    public Node last;

    //入栈
    public boolean offer(int val) {
    
    
        Node node = new Node(val);
        if(this.first == null) {
    
    
            this.first = node;
            this.last = node;
        }else {
    
    
            this.last.next = node;
            this.last = node;
        }
        return true;
    }

    //判断栈是否为空
    public boolean isEmpty() {
    
    
        if(this.first == null && this.last == null) {
    
    
            return true;
        }
        return false;
    }

    //出栈
    public int poll() throws RuntimeException{
    
    
        if(isEmpty()) {
    
    
            throw new RuntimeException("队列为空");
        }
        int ret = this.first.val;
        this.first = this.first.next;
        return ret;
    }

    //得到队头元素
    public int peek() {
    
    
        if(isEmpty()) {
    
    
            throw new RuntimeException("队列为空");
        }
        return this.first.val;
    }

}

Implementar colas con pilas

Enlace Likou

class MyQueue {
    
    
    Stack<Integer> a;
    Stack<Integer> b;

    /** Initialize your data structure here. */
    public MyQueue() {
    
    
        a = new Stack<>();
        b = new Stack<>();
    }
    
    /** Push element x to the back of queue. */
    public void push(int x) {
    
    
        a.push(x);
    }
    
    /** Removes the element from in front of queue and returns that element. */
    public int pop() {
    
    
        if(b.empty()) {
    
    
            int size = a.size();
            for(int i = 0; i < size; i++) {
    
    
                b.push(a.pop());
            }
        }
        return b.pop();
    }
    
    /** Get the front element. */
    public int peek() {
    
    
        if(b.empty()) {
    
    
            int size = a.size();
            for(int i = 0; i < size; i++) {
    
    
                b.push(a.pop());
            }
        }
        return b.peek();
    }
    
    /** Returns whether the queue is empty. */
    public boolean empty() {
    
    
        return a.empty() && b.empty();
    }
}

Cola circular

Enlace Likou

Soluciones

Lanza la pregunta: ¿Se puede implementar la cola como una matriz?

Respuesta: Sí, si piensa en la matriz como un anillo, inserte los datos en la cabecera de la matriz cuando la matriz esté llena, formando así una cola circular.

Pregunta 1: Cuando la parte delantera y trasera se encuentran, ¿están vacías o llenas?

Solución:
sacrificar un espacio para determinar si está lleno.
Determinar si el siguiente de la parte trasera actual está al frente.

---

Pregunta 2: ¿Tanto el delantero como el trasero enfrentan un problema de fuera de límites?

Solución:
agregue un juicio condicional.
Cuando (trasero + 1)% len == delantero, se producirá la conversión de espacio

---

Código

class MyCircularQueue {
    
    
    public int[] arr;
    public int rear;    //队尾
    public int front;   //队首
    public int len;

    public MyCircularQueue(int k) {
    
    
        arr = new int[k+1];
        len = k+1;
    }
    
    public boolean enQueue(int value) {
    
    
        if(isFull()) return false;
        arr[rear%len] = value;
        rear++;
        return true;
    }
    
    public boolean deQueue() {
    
    
        if(isEmpty()) return false;
        front++;
        return true;
    }
    
    public int Front() {
    
    
        if(isEmpty()) return -1;
        return arr[front%len];
    }
    
    public int Rear() {
    
    
        if(isEmpty()) return -1;
        return arr[(rear-1)%len]; 
    }
    
    public boolean isEmpty() {
    
    
        return rear == front;
    }
    
    public boolean isFull() {
    
    
        return (rear+1)%len == (front)%len;
    }
}