Implémentation Java LeetCode 622 file d'attente de cycle de conception (Dafa de la violence)

file d'attente cyclique 622. design

Concevoir l'implémentation de file d'attente circulaire. file d'attente circulaire est une structure de données linéaire, la performance de fonctionnement sur la base de FIFO (First In First Out) principe et est relié à la queue après que la tête de la file d'attente pour former une boucle. Il est également connu comme un « tampon circulaire. »

L'un des avantages file d'attente circulaire est utilisée avant de pouvoir utiliser cet espace de file d'attente. Dans une file d'attente normale, une fois une file d'attente est pleine, nous ne pouvons pas insérer l'élément suivant, même s'il y a encore de la place à l'avant de la file d'attente. Cependant, l'utilisation de la file d'attente circulaire, nous pouvons utiliser l'espace pour stocker la nouvelle valeur.

Vous devez appuyer la mise en œuvre des opérations suivantes:

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

exemple:

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
 

Conseils:

Toutes les valeurs sont dans l'intervalle de 0 à 1000;
opérandes dans la plage de 1 à 1000;
ne pas utiliser la file d' attente de base de données intégré.

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();
 */