# [LeetCode] 232. 225 Implement Queue/Stack using Stacks/Queues

## Problem 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.
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).

## Solution 232. Implement Queue using Stacks

``````class MyQueue {

Stack<Integer> input;
Stack<Integer> output;
/** Initialize your data structure here. */
public MyQueue() {
input = new Stack<>();
output = new Stack<>();
}

/** Push element x to the back of queue. */
public void push(int x) {
input.push(x);
}

/** Removes the element from in front of queue and returns that element. */
public int pop() {
peek();
return output.pop();
}

/** Get the front element. */
public int peek() {
if (output.isEmpty()) {
while (!input.isEmpty()) output.push(input.pop());
}
return output.peek();
}

/** Returns whether the queue is empty. */
public boolean empty() {
return input.isEmpty() && output.isEmpty();
}
}
``````

## Problem 225. Implement Stack using Queues

Implement the following operations of a stack using queues.

push(x) -- Push element x onto stack.
pop() -- Removes the element on top of the stack.
top() -- Get the top element.
empty() -- Return whether the stack is empty.
Example:

``````MyStack stack = new MyStack();

stack.push(1);
stack.push(2);
stack.top();   // returns 2
stack.pop();   // returns 2
stack.empty(); // returns false``````

Notes:

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

## Solution 225. Implement Stack using Queues

### Using one queue

``````class MyStack {

Queue<Integer> q;
/** Initialize your data structure here. */
public MyStack() {
}

/** Push element x onto stack. */
public void push(int x) {
q.offer(x);
for (int i = 1; i < q.size(); i++) q.offer(q.poll());
}

/** Removes the element on top of the stack and returns that element. */
public int pop() {
return q.isEmpty() ? -1 : q.poll();
}

/** Get the top element. */
public int top() {
return q.isEmpty() ? -1 : q.peek();
}

/** Returns whether the stack is empty. */
public boolean empty() {
return q.isEmpty();
}
}``````

### Using two queues

``````class MyStack {

Queue<Integer> q1;
Queue<Integer> q2;
/** Initialize your data structure here. */
public MyStack() {
}

/** Push element x onto stack. */
public void push(int x) {
if (q1.isEmpty()) {
q1.offer(x);
for (int i = 0; i < q2.size(); i++) q1.offer(q2.poll());
} else {
q2.offer(x);
for (int i = 0; i < q1.size(); i++) q2.offer(q1.poll());
}
}

/** Removes the element on top of the stack and returns that element. */
public int pop() {
if (q1.isEmpty()) return q2.poll();
else return q1.poll();
}

/** Get the top element. */
public int top() {
if (q1.isEmpty() && q2.isEmpty()) return -1;
else return q1.isEmpty() ? q2.peek() : q1.peek();
}

/** Returns whether the stack is empty. */
public boolean empty() {
return q1.isEmpty() && q2.isEmpty();
}
}``````