LeetCode题练习与总结：用队列实现栈--225

一、题目描述

请你仅使用两个队列实现一个后入先出（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（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

提示：

• 1 <= x <= 9
• 最多调用100 次 push、pop、top 和 empty
• 每次调用 pop 和 top 都保证栈不为空

二、解题思路

我们可以使用两个队列来实现栈的操作。假设这两个队列分别为queue1和queue2。我们主要使用queue1来进行操作，而queue2作为辅助队列。

以下是每个操作的实现思路：

1. push(int x)：每次添加元素时，我们都将其添加到queue1的末尾。这样，queue1的末尾元素始终是最后被添加的元素，即栈顶元素。

2. pop()：为了移除栈顶元素，我们需要将queue1中的元素（除了最后一个）依次出队并入队到queue2中，这样queue1的最后一个元素就是我们要移除的栈顶元素。然后交换queue1和queue2的角色，这样queue1又是空的，我们可以继续往里添加新的元素。

3. top()：与pop()类似，我们需要将queue1中的元素（除了最后一个）依次出队并入队到queue2中，然后获取queue1的最后一个元素（即栈顶元素）。但是，我们需要在获取元素后，将其重新加入到queue2中，并交换queue1和queue2的角色，以保持栈的结构。

4. empty()：检查queue1是否为空即可，因为所有元素都在queue1中。

三、具体代码

import java.util.LinkedList;
import java.util.Queue;

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

    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }
    
    public void push(int x) {
        queue1.offer(x);
    }
    
    public int pop() {
        while (queue1.size() > 1) {
            queue2.offer(queue1.poll());
        }
        int top = queue1.poll();
        Queue<Integer> temp = queue1;
        queue1 = queue2;
        queue2 = temp;
        return top;
    }
    
    public int top() {
        while (queue1.size() > 1) {
            queue2.offer(queue1.poll());
        }
        int top = queue1.poll();
        queue2.offer(top);
        Queue<Integer> temp = queue1;
        queue1 = queue2;
        queue2 = temp;
        return top;
    }
    
    public boolean empty() {
        return queue1.isEmpty();
    }
}

四、时间复杂度和空间复杂度

1. 时间复杂度

• push(int x)：将元素添加到队列的末尾是一个常数时间操作，因此push操作的时间复杂度是O(1)。

• pop()：在最坏情况下，队列queue1中可能有n个元素，我们需要将n-1个元素从queue1移动到queue2，然后再将queue1和queue2交换。每次操作（入队和出队）都是常数时间操作，因此pop操作的时间复杂度是O(n)，其中n是栈中元素的数量。

• top()：与pop()操作类似，我们需要将n-1个元素从queue1移动到queue2，然后获取栈顶元素并将其放回queue2。每次操作（入队和出队）都是常数时间操作，因此top操作的时间复杂度是O(n)，其中n是栈中元素的数量。

• empty()：检查队列是否为空是一个常数时间操作，因此empty操作的时间复杂度是O(1)。

2. 空间复杂度

• push(int x)：每个元素都是直接存储在队列中，所以push操作的空间复杂度是O(1)。

• pop()：我们使用了一个额外的队列queue2来临时存储元素，但是queue2的大小不会超过原始队列queue1的大小，因此pop操作的空间复杂度是O(n)，其中n是栈中元素的数量。

• top()：与pop()操作类似，我们使用了额外的队列queue2，所以top操作的空间复杂度也是O(n)，其中n是栈中元素的数量。

• empty()：没有使用额外的空间，所以empty操作的空间复杂度是O(1)。

五、总结知识点

• 构造函数：

  • public MyStack()：定义了类的构造函数，用于初始化成员变量queue1和queue2为LinkedList对象。

• 队列操作：

  • offer(int x)：向队列末尾添加元素。
  • poll()：从队列头部移除并返回元素。
  • size()：返回队列中的元素数量。
  • isEmpty()：检查队列是否为空。

• 方法重载：

  • 类中定义了多个名为push、pop、top和empty的方法，它们具有不同的参数列表和返回类型，这是方法重载的体现。

• 数据结构：

  • Queue：表示队列数据结构，用于先进先出（FIFO）操作。
  • LinkedList：实现了Queue接口，提供了队列操作的实现。

• 算法逻辑：

  • 在pop和top方法中，通过将queue1中的元素（除了最后一个）转移到queue2中，实现了队列到栈的转换，即后进先出（LIFO）的操作。

• 临时变量：

  • 使用Queue<Integer> temp作为临时变量，用于交换queue1和queue2的角色，保持栈的结构。

• 返回值：

  • 方法pop和top返回整数类型的数据，表示栈顶元素。
  • 方法empty返回布尔类型的数据，表示栈是否为空。

• 类型转换：

  • 在push方法中，使用了自动装箱（Autoboxing）将基本数据类型int转换为包装类Integer。

• 异常处理：

  • 虽然代码中没有显式处理异常，但poll方法在队列为空时返回null，在pop和top方法中应确保队列不为空，以避免NullPointerException。

以上就是解决这个问题的详细步骤，希望能够为各位提供启发和帮助。