[LeetCode] 232. Implement Queue Using Stacks

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.
Notes:
  • You must use only standard operations of a stack -- which means only push to toppeek/pop from topsize, 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).

Thought process:
Use two stacks: one for push and the other for pop and peek.

Solution:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public class MyQueue {
    private Stack<Integer> toPush;
    private Stack<Integer> toPop;

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

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

Time complexity: 
Push, pop, and peek are amortized O(1). Empty is O(1).

Comments

Popular posts from this blog

[LeetCode] 714. Best Time to Buy and Sell Stock with Transaction Fee

[LeetCode] 269. Alien Dictionary

[LeetCode] 631. Design Excel Sum Formula