[Swift]LeetCode232. 用栈实现队列 | Implement Queue using Stacks

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10204818.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Implement the following operations of a queue using stacks.

• push(x) -- Push element x to the back of queue.
• pop() -- Removes the element from in front of queue.
• peek() -- Get the front element.
• empty() -- Return whether the queue is empty.

Example:

MyQueue queue = new MyQueue();

queue.push(1);
queue.push(2);  
queue.peek();  // returns 1
queue.pop();   // returns 1
queue.empty(); // returns false

Notes:

• You must use only standard operations of a stack -- which means only push to top, peek/pop from top, size, and is empty operations are valid.
• Depending on your language, stack may not be supported natively. You may simulate a stack by using a list or deque (double-ended queue), as long as you use only standard operations of a stack.
• You may assume that all operations are valid (for example, no pop or peek operations will be called on an empty queue).

---

使用栈实现队列的下列操作：

• push(x) -- 将一个元素放入队列的尾部。
• pop() -- 从队列首部移除元素。
• peek() -- 返回队列首部的元素。
• empty() -- 返回队列是否为空。

示例:

MyQueue queue = new MyQueue();

queue.push(1);
queue.push(2);  
queue.peek();  // 返回 1
queue.pop();   // 返回 1
queue.empty(); // 返回 false

说明:

• 你只能使用标准的栈操作 -- 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
• 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
• 假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）。

---

8ms

class MyQueue {
    
    var input = [Int]()
    var output = [Int]()
    
    func push(_ x: Int) {
        input.append(x)
    }
    
    func pop() -> Int {
        if output.isEmpty {
            inputToOutput()
        }
        return output.removeLast()
    }
    
    func inputToOutput() {
        while !input.isEmpty {
            output.append(input.removeLast())
        }
    }
    
    func peek() -> Int {
        if output.isEmpty {
            inputToOutput()
        }
        return output.last!
    }
    
    func empty() -> Bool {
        return input.isEmpty && output.isEmpty
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * let obj = MyQueue()
 * obj.push(x)
 * let ret_2: Int = obj.pop()
 * let ret_3: Int = obj.peek()
 * let ret_4: Bool = obj.empty()
 */
 

---

12ms

class MyQueue {

    private var oldStack: [Int]
    private var newStack: [Int]
    /** Initialize your data structure here. */
    init() {
        oldStack = [Int]()
        newStack = [Int]()
    }
    
    /** Push element x to the back of queue. */
    func push(_ x: Int) {
      newStack.append(x)
    }
    
    /** Removes the element from in front of queue and returns that element. */
    func pop() -> Int {
                shiftStack()

      return oldStack.removeLast()
    }
    
    /** Get the front element. */
    func peek() -> Int {
        shiftStack()
      return oldStack.last!
    }
    
    /** Returns whether the queue is empty. */
    func empty() -> Bool {
      return oldStack.isEmpty && newStack.isEmpty
    }
    private func shiftStack() {
        if oldStack.isEmpty {
            while !newStack.isEmpty {
             oldStack.append(newStack.removeLast())
            }
        }
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * let obj = MyQueue()
 * obj.push(x)
 * let ret_2: Int = obj.pop()
 * let ret_3: Int = obj.peek()
 * let ret_4: Bool = obj.empty()
 */
 

---

12ms

class Stack {
    
    private var nums: [Int] = []
    
    var isEmpty: Bool {
        return nums.isEmpty
    }
    
    func push(_ x: Int) {
        nums.append(x)
    }
    
    func pop() -> Int? {
        return nums.popLast()
    }
    
    func peek() -> Int? {
        return nums.last
    }
    
}

class MyQueue {
    
    private let stack = Stack()
    private let stack2 = Stack()

    /** Initialize your data structure here. */
    init() {
        
    }
    
    /** Push element x to the back of queue. */
    func push(_ x: Int) {
        stack.push(x)
    }
    
    /** Removes the element from in front of queue and returns that element. */
    func pop() -> Int {
        if stack2.isEmpty {
            while let num = stack.pop() {
                stack2.push(num)
            }
        }
        
        return stack2.pop() ?? 0
    }
    
    /** Get the front element. */
    func peek() -> Int {
        if stack2.isEmpty {
            while let num = stack.pop() {
                stack2.push(num)
            }
        }
        
        return stack2.peek() ?? 0
    }
    
    /** Returns whether the queue is empty. */
    func empty() -> Bool {
      return stack.isEmpty && stack2.isEmpty
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * let obj = MyQueue()
 * obj.push(x)
 * let ret_2: Int = obj.pop()
 * let ret_3: Int = obj.peek()
 * let ret_4: Bool = obj.empty()
 */
 

---

16ms

class MyQueue {

    fileprivate var stack = [Int?]()
    fileprivate var reserveStack = [Int?]()
    
    
    /** Initialize your data structure here. */
    init() {
        stack = [Int]()
        reserveStack = [Int]()
    }
    
    /** Push element x to the back of queue. */
    func push(_ x: Int) {
        if reserveStack.isEmpty{
            stack.append(x)
        }else{
            // 翻转reserveStack
            while !reserveStack.isEmpty {
                stack.append(reserveStack.popLast()!)
            }
            stack.append(x)
        }
        
    }
    
    /** Removes the element from in front of queue and returns that element. */
    func pop() -> Int {
        
        // 原栈为空，说明数据翻转到reserve栈中
        if stack.isEmpty{
            return reserveStack.removeLast()!
        }
        
        // 翻转stack
        while !stack.isEmpty {
            reserveStack.append(stack.removeLast())
        }
        
        return reserveStack.removeLast()!
    }
    
    /** Get the front element. */
    func peek() -> Int {
       
        // 原栈为空，说明数据翻转到reserve栈中
        if stack.isEmpty{
            return reserveStack.last!!
        }
        
        // 翻转stack
        while !stack.isEmpty {
            reserveStack.append(stack.removeLast()!)
        }
        
        return reserveStack.last!!
    }
    
    /** Returns whether the queue is empty. */
    func empty() -> Bool {
        
        if stack.isEmpty && reserveStack.isEmpty {
            return true
        }
        
        return false
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * let obj = MyQueue()
 * obj.push(x)
 * let ret_2: Int = obj.pop()
 * let ret_3: Int = obj.peek()
 * let ret_4: Bool = obj.empty()
 */
 

---

20ms

class MyQueue {

   var queue : [Int]
    /** Initialize your data structure here. */
    init() {
        self.queue = [Int]()
    }
    
    /** Push element x to the back of queue. */
    func push(_ x: Int) {
        self.queue.insert(x, at: 0)
    }
    
    /** Removes the element from in front of queue and returns that element. */
    func pop() -> Int {
        return self.queue.removeLast()
    }
    
    /** Get the front element. */
    func peek() -> Int {
        return self.queue.last!
    }
    
    /** Returns whether the queue is empty. */
    func empty() -> Bool {
        return self.queue.isEmpty
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * let obj = MyQueue()
 * obj.push(x)
 * let ret_2: Int = obj.pop()
 * let ret_3: Int = obj.peek()
 * let ret_4: Bool = obj.empty()
 */