循环队列

循环队列【力扣】

循环队列一般有两种实现方式:

1. 传统方式 : 牺牲一个空间 —> 区分队列为空和队列满
2. 维护size的方式 —> 比较简单 —> 适合算法中确保正确率

传统方式:

注意点:

1. 初始化 : front = 0; rear = 0;
   • 一定要理解循环不变量的定义, 你就能清楚这里为什么rear起始是0 —> 因为我们的队列区间为[front, rear - 1]
2. 判断队列为空 : rear == front
3. 判断队列满 : (rear - 1 + data.length) % data.length
4. 使用这种方式要浪费一个空间, 所以初始的时候创建容量为k的队列的时候底层data[]长度要为k + 1

class MyCircularQueue {
    int [] data;
    int front;
    int rear;
    public MyCircularQueue(int k) {
        //初始化长度为k的循环队列
        data = new int[k + 1];
        //开始的时候rear为-1, 表示队列中没有元素 ---> 如果是使用front和rear的关系来维护环形队列, 那么我们初始rear的时候肯定是初始为0,因为一个位置是不能使用的
        front = 0;
        rear = 0;
    }

    public boolean enQueue(int value) {
        //首先判断队列是否已经满了 ---> 如果已经满了, 那么return false
        if(!isFull()) {
            data[rear] = value;
            rear = (rear + 1) % data.length;
        }else
            return false;
        return true;
    }

    public boolean deQueue() {
        //首先判断队列是否为空
        if(!isEmpty()) {
            front = (front + 1) % data.length;
        }else
            return false;
        return true;
    }

    public int Front() {
        //注意: 我们如果队列为空的时候, 这个时候根据题目要求返回一个-1
        return isEmpty() ? -1 : data[front];
    }

    public int Rear() {
        return isEmpty() ? -1 : data[(rear - 1 + data.length) % data.length];
    }

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

    public boolean isFull() {
        return (rear + 1) % data.length == front;
    }
}

维护size方式:

这种方式比较简单, 判断队列是否为空, 是否满都是通过size的大小直接判断的

注意点 :

1. 初始化 : front = 0; rear = -1
   • 也是一样的. 搞懂循环不变量, 之所以这样初始化是因为队列的范围是 : [front , rear]
2. 判断队列空 : this.size == 0
3. 判断队列满 : this.size == data.length

class MyCircularQueue {
    int [] data;
    int front;
    int rear;
    //记录当前队列中有多少元素
    int size;
    public MyCircularQueue(int k) {
        //初始化长度为k的循环队列
        data = new int[k];
        //开始的时候rear为-1, 表示队列中没有元素 ---> 如果是使用front和rear的关系来维护环形队列, 那么我们初始rear的时候肯定是初始为0,因为一个位置是不能使用的
        front = 0;
        rear = -1;
        size = 0;
    }

    public boolean enQueue(int value) {
        //首先判断队列是否已经满了 ---> 如果已经满了, 那么return false
        if(!isFull()) {
            rear = (rear + 1) % data.length;
            data[rear] = value;
            size++;
        }else
            return false;
        return true;
    }

    public boolean deQueue() {
        //首先判断队列是否为空
        if(!isEmpty()) {
            front = (front + 1) % data.length;
            size--;
        }else
            return false;
        return true;
    }

    public int Front() {
        //注意: 我们如果队列为空的时候, 这个时候根据题目要求返回一个-1
        return isEmpty() ? -1 : data[front];
    }

    public int Rear() {
        return isEmpty() ? -1 : data[rear];
    }

    public boolean isEmpty() {
        return this.size == 0;
    }

    public boolean isFull() {
        return this.size == data.length;
    }
}

说明:

1. 在循环队列中如果是rear = rear + 1, 这个时候为了防止越界, 我们一般都是 rear = (rear + 1) % data.length
2. 还有一种情况如果是rear = rear - 1, 这个时候为了防止越界, 我们一般有两种常用做法:
   1. rear = (rear - 1 + data.length) % data.length
   2. if(–rear < 0) rear += data.length
      • 这个第二种比较难理解 , 就是如果–rear > 0的时候直接就是只执行了–rear, 相当于是rear = rear - 1, 如果–rear < 0的时候, 这个时候就再执行一个 rear += data.length