实现一个循环队列

  思想：顾名思义，要实现一个循环队列，我们需要设计一个环，用front来记录头位置，用rear来记录尾巴的位置，然后实现各种操作，重点就是，这里我们需要牺牲一个空间来判断当前队列是否为满， 当front==rear时，队列为空，当front==(rear+)%数组的长度时，队列为满，但是在书写的代码的时候，里面也有注意的细节问题，如图：

MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。
class MyCircularQueue {
    private int[] elem;//创建一个数组
    private int front;//记录头的位置
    private int rear;//记录尾巴的位置
 
    public MyCircularQueue(int k) {
        this.elem = new int[k+1];//这里我们牺牲了一个空间，所以这里要给数组加一个长度
    }
 
    public boolean enQueue(int value) {
        if (isFull()) {
            return false;
        }
        elem[rear] = value;
        rear = (rear + 1) % elem.length;
        return true;
    }
 
    public boolean deQueue() {
        if (isEmpty()) {
            return false;
        }
        front = (front + 1) % elem.length;
        return true;
    }
 
    public int Front() {
        if (isEmpty()) {
            return -1;
        }
        return elem[front];
 
    }
 
    public int Rear() {
        if (isEmpty()) {
            return -1;
        }
        int index=(rear==0)?elem.length-1:rear-1;//这里需要处理一下，对尾巴的记录有2中情况
        return elem[index];
    }
 
    public boolean isEmpty() {
        return front == rear;
    }
 
    public boolean isFull() {
        if ((rear + 1) % elem.length == front) {
            return true;
        } else {
            return false;
        }
    }
 
}

✅每日一练：225. 用队列实现栈 - 力扣（LeetCode）

        核心思想：这里需要2个队列来实现一个栈，入队列时候，我们需要判断2个队列哪个为空，如果哪个为空，我们就把元素放到哪个队列里，如果2个队列都为空，我们就放到第一个队列，然后模拟出栈的时候，我们将队列的元素出Queue.size-1个元素，剩下的一个元素就是我们要出栈的元素，让pop一下就好了！

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。
import java.util.LinkedList;
import java.util.Queue;
 
/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Snk
 * Date: 2023-02-06
 * Time: 21:50
 */
 
/**
 * 用队列实现栈
 */
class MyStack {
    private Queue<Integer> qu1;
    private Queue<Integer> qu2;
 
    public MyStack() {
        qu1 = new LinkedList<>();
        qu2 = new LinkedList<>();
    }
 
    public void push(int x) {
        if (!qu1.isEmpty()) {
            qu1.offer(x);
        } else if (!qu2.isEmpty()) {
            qu2.offer(x);
        }else {
            qu1.offer(x);
        }
 
    }
 
    public int pop() {
        if (empty()) {
            return -1;
        }
        if (!qu1.isEmpty()) {
            int length = qu1.size();
            for (int i = 0; i < length - 1; i++) {
                int val = qu1.poll();
                qu2.offer(val);
            }
            return qu1.poll();
        }
        else {
            int length = qu2.size();
            for (int i = 0; i < length - 1; i++) {
                int val = qu2.poll();
                qu1.offer(val);
            }
            return qu2.poll();
        }
    }
 
    public int top() {
        if (empty()) {
            return -1;
        }
        if (!qu1.isEmpty()) {
            int length = qu1.size();
            int val=-1;
            for (int i = 0; i < length; i++) {
                 val = qu1.poll();
                qu2.offer(val);
            }
            return val;
        }
        else {
            int length = qu2.size();
            int val=-1;
            for (int i = 0; i < length ; i++) {
                 val = qu2.poll();
                qu1.offer(val);
            }
            return val;
        }
    }
 
    public boolean empty() {
        return qu1.isEmpty() && qu2.isEmpty();
    }
}

✅每日一练：232. 用栈实现队列 - 力扣（LeetCode）

思想： 这里需要2个栈来实现，把元素全部放到第一个栈中，再将第一个栈的元素放到第二个栈中，此时栈顶的元素就是我们要出队列的元素，依次下去可以完成操作；

void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 fals
import java.util.Stack;
 
/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Snk
 * Date: 2023-02-07
 * Time: 12:50
 */
class MyQueue {
    private Stack<Integer> stack1;
    private Stack<Integer> stack2;
 
    public MyQueue() {
        this.stack1 = new Stack<>();
        this.stack2 = new Stack<>();
 
    }
 
    public void push(int x) {
        stack1.push(x);
    }
 
    public int pop() {
        if(empty()){
            return -1;
        }
        if (stack2.isEmpty()) {
            while (!stack1.isEmpty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }
 
    public int peek() {
        if(empty()){
            return -1;
        }
        if (stack2.isEmpty()) {
            while (!stack1.isEmpty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.peek();
    }
 
    public boolean empty() {
        return stack1.isEmpty() && stack2.isEmpty();
    }
}