#用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（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（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例 1：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

提示：

1 <= x <= 9
最多调用 100 次 push、pop、peek 和 empty
假设所有操作都是有效的（例如，一个空的队列不会调用 pop 或者 peek 操作）

进阶：

你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。

#解题思路

题目信息：两个栈，每个操作时间复杂度为 O(1)

#思路一

首先想到维护输入输出两个栈，输入时直接输入，并只维护输入栈的值，输出时将输入栈的复制内容弹出并压入输出栈，然后输出，保持输入栈值不变,复杂度 pop 与 peek 都是 O(n)

#首次代码

class MyQueue {
  private input = []
  private output = []

  constructor() {}

  push(x: number): void {
    this.input.push(x)
  }

  pop(): number {
    while (this.input.length > 0) {
      this.output.push(this.input.pop())
    }
    const res = this.output.pop()
    while (this.output.length > 0) {
      this.input.push(this.output.pop())
    }
    return res
  }

  peek(): number {
    const inputCopy = [...this.input]
    while (inputCopy.length > 0) {
      this.output.push(inputCopy.pop())
    }
    const res = this.output.pop()
    this.output = []
    return res
  }

  empty(): boolean {
    return this.input.length === 0
  }
}

#代码优化

写的时候就感觉不对劲，没必要单纯维护 input 的值，输入时存入 input，转化到 output 的值转了就转了，输出完再从 input 拿就好了，这样降低很多复杂度，就是进阶要求的均摊为 O(1)

constructor 可以去掉，因为类字段写法定义变量时相当于在 constructor 内初始化

class MyQueue {
  private input = []
  private output = []

  push(x: number): void {
    this.input.push(x)
  }

  pop(): number {
    !this.output.length && this.in2out()
    return this.output.pop()
  }

  peek(): number {
    !this.output.length && this.in2out()
    return this.output[this.output.length - 1]
  }

  empty(): boolean {
    return this.input.length === 0 && this.output.length === 0
  }

  in2out(): void {
    while (this.input.length > 0) {
      this.output.push(this.input.pop())
    }
  }
}

#复习代码

class MyQueue {
  in: number[] = []
  out: number[] = []

  push(x: number): void {
    this.in.push(x)
  }

  pop(): number {
    if (!this.out.length) {
      this.in2out()
    }

    return this.out.pop() ?? -1
  }

  peek(): number {
    if (!this.out.length) {
      this.in2out()
    }

    return this.out[this.out.length - 1]
  }

  empty(): boolean {
    return this.in.length + this.out.length === 0
  }

  in2out() {
    while (this.in.length) {
      this.out.push(this.in.pop())
    }
  }
}

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