Day 10 | 232. Implement Queue using Stacks | 225. Implement Stack using Queue

Day 1 | 704. Binary Search | 27. Remove Element | 35. Search Insert Position | 34. First and Last Position of Element in Sorted Array

---

Basic Concept of the Stack and the Queue

• The stack is last-in-fist-out（LIFO）
• The queue is first in first out（FIFO）
• They don’t allow traversal, and don’t provide the iterator.
• The stack use pluggable containers to implement its function and provide unified interfaces to the outside world. That is, we can control what container to implement the part of the stack.

---

LeetCode 232. Implement Queue using Stacks

Question Link

Solution:

class MyQueue {
    Stack<Integer> stackIn;
    Stack<Integer> stackOut; 

    // Initiallize the data structure
    public MyQueue() { 
        stackIn = new Stack<>();  
        stackOut = new Stack<>();
    }
    
    public void push(int x) {
        stackIn.push(x);
    }
    
    public int pop() {
        dumpStackIn();
        return stackOut.pop();
    }
    
    public int peek() {
        dumpStackIn();
        return stackOut.peek();
    }
    
    public boolean empty() {
        return stackIn.isEmpty()&&stackOut.isEmpty();
    }

    //If the stackOut is empty, dump all of the elements of the stackIn into the stackOut
    private void dumpStackIn(){
        if(!stackOut.isEmpty())
            return;
        while(!stackIn.isEmpty()){
            stackOut.push(stackIn.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();
 */

Thought:

• When popping the stack:
  • If the stackOut is empty, dump all of the elements of the stackIn into the stackOut. Then do pop() from the stackOut
  • If the stackOut is not empty, do pop() directly from the stackOut

---

LeetCode 225. Implement Stack using Queues

Question Link

Solution:
1、Use two queues for implementation

class MyStack {
    Queue<Integer> queue1;
    Queue<Integer> queue2; // auxiliary queue for backup
    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }
    
    public void push(int x) {
        // put x in to auxiliary queue first
        queue2.offer(x);
        // then dump all elements of the queue1 in to the queue2
        while(!queue1.isEmpty())
            queue2.offer(queue1.poll());
        // dump all elements of the queue2 into queue1
        Queue<Integer> queueTemp = new LinkedList<>();
        queue1 = queue2;
        queue2 = queueTemp;
    }   
    
    public int pop() {
       return queue1.poll();
    }
    
    public int top() {
        return queue1.peek();
    }
    
    public boolean empty() {
        return queue1.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();
 */

Thought:

• Put x in to auxiliary queue2 first
• Dump all elements of the queue1 in to the queue2
• Dump all elements of the queue2 into queue1

2、Use one queue for implementation

class MyStack {
    Queue<Integer> queue;
    public MyStack() {
        queue = new LinkedList<>();
    }
    
    // When push a `x`, reorder the queue. Put the `x` at the front of the queue
    public void push(int x) {
        queue.offer(x);
        int size = queue.size();
        // move all of the elements except `x`
        while(size-- > 1)
            queue.offer(queue.poll());
    }   
    
    public int pop() {
       return queue.poll();
    }
    
    public int top() {
        return queue.peek();
    }
    
    public boolean empty() {
        return queue.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();
 */

Thought:

• When push a x, reorder the queue. Put the x at the front of the queue
• In the while loop, move all of the elements except x