用栈实现队列，用队列实现栈，最小栈，设计循环队列的Java做法

Posted 2022-12-08 小猪媛不圆

• 用队列实现栈
• 用栈实现队列
• 最小栈
• 设计循环队列

用队列实现栈

奉上链接：用队列实现栈
题目描述：

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通队列的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。 int pop() 移除并返回栈顶元素。 int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false。

注意：

你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty
这些操作。 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 ,
只要是标准的队列操作即可。

下面是评论区大神的解法

class MyStack 
    private Queue<Integer> queue1;
    private Queue<Integer> queue2;

    /** Initialize your data structure here. */
    public MyStack() 
        queue1 =new LinkedList<>();
        queue2 =new LinkedList<>();
    
    
    /** Push element x onto stack. */
    public void push(int x) 
        queue1.offer(x);
        //将2队列中的元素全部转给1队列
        while(!queue2.isEmpty()) 
            queue1.offer(queue2.poll());
        
        //交换1和2，使得1队列在没有push()的时候始终为空队列
        Queue temp = queue1;
        queue1 = queue2;
        queue2 = temp;
    
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() 
        return queue2.poll();
    
    
    /** Get the top element. */
    public int top() 
        return queue2.peek();
    
    
    /** Returns whether the stack is empty. */
    public boolean empty() 
        return queue2.isEmpty();
    


/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

• 关于最重要的一段代码的理解，也就是下面这段代码，可以参考这样的图解。
• 
• 最初的两个栈
  

用栈实现队列

题目链接：用栈实现队列
题目描述：

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：
实现 MyQueue 类：
void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false
说明：
你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

• 参考代码实现如下：

class MyQueue 

    private Stack<Integer> stack1 ;
    private Stack<Integer> stack2 ;

    /** Initialize your data structure here. */
    public MyQueue() 
        stack1 = new Stack<>();
        stack2 = new Stack<>();
    
    
    /** Push element x to the back of queue. */
    public void push(int x) 
        stack1.push(x);
    
    
    /** Removes the element from in front of queue and returns that element. */
    public int pop() 
        if(stack2.isEmpty()) 
            while(!stack1.isEmpty())
                stack2.push(stack1.pop());
            
        
        return stack2.pop();
    
    
    /** Get the front element. */
    public int peek() 
        if(stack2.isEmpty())
            while(!stack1.isEmpty()) 
                stack2.push(stack1.pop());
            
        
        return stack2.peek();
    
    
    /** Returns whether the queue is empty. */
    public boolean empty() 
        return stack1.isEmpty() && stack2.isEmpty();
    


/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */

最小栈

题目链接：最小栈
题目描述：

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。

参考代码：

class MinStack 

    private int min = Integer.MAX_VALUE;
    private Stack<Integer> stack;
    /** initialize your data structure here. */
    public MinStack() 
        stack = new Stack<>();
    
    
    public void push(int x) 
        if(min >= x) 
            stack.push(min);
            min = x;
        
        stack.push(x);
    
    
    public void pop() 
        if(stack.pop() == min) 
            min = stack.pop();
        
    
    
    public int top() 
        return stack.peek();
    
    
    public int getMin() 
        return min;
    


/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

设计循环队列

题目链接：设计循环队列
题目描述：

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
你的实现应该支持如下操作：
MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。

参考代码：

class MyCircularQueue 
    int[] array;
    int head;
    int tail;

    public MyCircularQueue(int k) 
        this.array = new int[k];
        for(int i = 0; i < k; i++) 
            array[i] = -1;
        
    
    
    public boolean enQueue(int value) 
        if(isFull()) return false;
        array[tail] = value;
        tail++;
        if(tail == array.length) tail = 0;
        return true;
    
    
    public boolean deQueue() 
        if(isEmpty()) return false;
        array[head] = -1;
        head++;
        if(head == array.length) head = 0;
        return true;

    
    
    public int Front() 
        return array[head];

    
    
    public int Rear() 
        if(tail - 1 < 0) return array[array.length - 1];
        return array[tail - 1];

    
    
    public boolean isEmpty() 
        return tail == head && array[head] == -1;

    
    
    public boolean isFull() 
        return tail == head && array[head] != -1;

    


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