[leetcode622] design circular queue

Although but , Basic things are also written

subject

Design your loop queue implementation . Circular queue is a linear data structure , Its operation performance is based on FIFO（ fifo ） Principle and the end of the team is connected behind the head of the team to form a loop . It's also called “ Ring buffer ”.

One of the benefits of circular queues is that we can take advantage of the previously used space in this queue . In a normal queue , Once a queue is full , We can't insert the next element , There's room even in front of the queue . But with circular queues , We can use this space to store new values .

Your implementation should support the following operations ：
MyCircularQueue(k): Constructors , Set queue length to k .
Front: Get elements from team leader . If the queue is empty , return -1 .
Rear: Get team end element . If the queue is empty , return -1 .
enQueue(value): Insert an element into the loop queue . True if successfully inserted .
deQueue(): Remove an element from the loop queue . True if deleted successfully .
isEmpty(): Check if the loop queue is empty .
isFull(): Check if the loop queue is full .

source ： Power button （LeetCode）
link ：https://leetcode.cn/problems/design-circular-queue
Copyright belongs to the network . For commercial reprint, please contact the official authority , Non-commercial reprint please indicate the source .

source ： Power button （LeetCode）
link ：https://leetcode.cn/problems/design-circular-queue
Copyright belongs to the network . For commercial reprint, please contact the official authority , Non-commercial reprint please indicate the source .

class MyCircularQueue {
    
    int[] queue;
    /* They are the head pointer and the tail pointer */
    int front,rear;
    int size;
    public MyCircularQueue(int k) {
    
        /* Create an array . Be able to distinguish between empty queues and full queues . Need to keep one more */
        /* When the head pointer and the tail pointer overlap, it indicates an empty queue */
        /* The tail pointer points to the next position of the last node in the queue */
        /* When the next position of the tail pointer is the head pointer , The queue is full */
        /* So it will waste a place */
        queue=new int[k+1];
        front=rear=0;
        /* The actual length of the queue , Used to calculate the position of the head pointer and the tail pointer after moving */
        size=k+1;
    }

    public boolean isEmpty() {
    
        return rear==front;
    }

    public boolean isFull() {
    
        /* When the line is full , Because it's a circular queue , The tail pointer may be in front of or behind the head pointer , Therefore, it is necessary to take the remainder */
        /* Remainder , The consideration is rear==size-1 The situation of */
        return (rear+1)%size==front;
    }

    public boolean enQueue(int value) {
    
        if(isFull())
            return false;
        else{
    
            queue[rear]=value;
            rear=(rear+1)%size;
            return true;
        }
    }

    public boolean deQueue() {
    
        if(isEmpty())
            return false;
        else {
    
            front=(front+1)%size;
            return true;
        }
    }

    public int Front() {
    
        if(isEmpty())
            return -1;
        else return queue[front];
    }

    public int Rear() {
    
        if(isEmpty())
            return -1;
        /* Also required in brackets +size, The consideration is rear==0 The situation of */
        else return queue[(rear-1+size)%size];
    }
}