Java aplicación LeetCode 622 cola de ciclo de diseño (violencia Dafa)

622. cola de ciclo de diseño

El diseño de su aplicación cola circular. cola circular es una estructura de datos lineal, el rendimiento de la operación basado en FIFO principio (First In First Out) y está conectado a la cola después de que la cabeza de la cola para formar un bucle. También se conoce como una "memoria intermedia de anillo."

Uno de los beneficios cola circular se utiliza antes de poder utilizar este espacio en la cola. En una cola normal, una vez a la cola está llena, no podemos insertar el siguiente elemento, incluso si todavía hay espacio en la parte delantera de la cola. Sin embargo, el uso de la cola circular, que puede utilizar el espacio para almacenar el nuevo valor.

Usted debe apoyar la implementación de las siguientes operaciones:

MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。

Ejemplo:

MyCircularQueue circularQueue = new MycircularQueue(3); // 设置长度为 3

circularQueue.enQueue(1);  // 返回 true

circularQueue.enQueue(2);  // 返回 true

circularQueue.enQueue(3);  // 返回 true

circularQueue.enQueue(4);  // 返回 false，队列已满

circularQueue.Rear();  // 返回 3

circularQueue.isFull();  // 返回 true

circularQueue.deQueue();  // 返回 true

circularQueue.enQueue(4);  // 返回 true

circularQueue.Rear();  // 返回 4
 

consejos:

Todos los valores están en el rango de 0 a 1000;
operandos en el rango de 1 a 1000;
no utilice la incorporada en la cola de la base de datos.

class MyCircularQueue {
private Integer []arr;
	private int head;
	private int tail;
    /** Initialize your data structure here. Set the size of the queue to be k. */
    public MyCircularQueue(int k) {
        arr=new Integer[k];
        head=0;
        tail=0;
    }
    
    /** Insert an element into the circular queue. Return true if the operation is successful. */
    public boolean enQueue(int value) {
        if(isFull()) {
        	return false;
        }else {
        	arr[tail]=value;
        	tail=(tail+1)%(arr.length);
            return true;
        }

    }
    
    /** Delete an element from the circular queue. Return true if the operation is successful. */
    public boolean deQueue() {
        if(isEmpty()) {
        	return false;
        }else {
        	arr[head]=null;
        	head=(head+1)%(arr.length);
        	return true;
        }
    }
    
    /** Get the front item from the queue. */
    public int Front() {
        if(isEmpty()) {
        	return -1;
        }else {
        	return arr[head];
        }
    }
    
    /** Get the last item from the queue. */
    public int Rear() {
    	 if(isEmpty()) {
         	return -1;
         }else {
             if(tail!=0)return arr[tail-1];
             else return arr[arr.length-1];
         }
    }
    
    /** Checks whether the circular queue is empty or not. */
    public boolean isEmpty() {
    	if(head==tail&&arr[head]==null) {
        	return true;
        }else {
        	return false;
        }
    }
    
    /** Checks whether the circular queue is full or not. */
    public boolean isFull() {
    	 if(head==tail&&arr[head]!=null) {
         	return true;
         }else {
        	 return false;
         }
    }
}

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * MyCircularQueue obj = new MyCircularQueue(k);
 * boolean param_1 = obj.enQueue(value);
 * boolean param_2 = obj.deQueue();
 * int param_3 = obj.Front();
 * int param_4 = obj.Rear();
 * boolean param_5 = obj.isEmpty();
 * boolean param_6 = obj.isFull();
 */