Directory
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
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 thestackIn
into thestackOut
. Then do pop() from thestackOut
- If the
stackOut
is not empty, do pop() directly from thestackOut
- If the
LeetCode 225. Implement Stack using Queues
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 auxiliaryqueue2
first - Dump all elements of the
queue1
in to thequeue2
- 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 thex
at the front of the queue - In the
while loop
, move all of the elements exceptx