Day 1 | 704. Binary Search | 27. Remove Element | 35. Search Insert Position | 34. First and Last Position of Element in Sorted Array
stack
is last-in-fist-out(LIFO
)queue
is first in first out(FIFO
)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.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:
stackOut
is empty, dump all of the elements of the stackIn
into the stackOut
. Then do pop() from the stackOut
stackOut
is not empty, do pop() directly from the stackOut
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:
x
in to auxiliary queue2
firstqueue1
in to the queue2
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:
x
, reorder the queue. Put the x
at the front of the queuewhile loop
, move all of the elements except x