面试中经常会问到这样的问题,利用两个堆栈实现一个队列以及利用两个队列实现一个堆栈。我们知道堆栈的特点是先进后出,而队列的特点是先进先出。这里我用java实现了一下,不对的地方还请大家及时指出。
两个堆栈实现一个队列思想:
(1)弹出时,如果stack2不为空的话,直接由stack2弹出,如果stack1不为空,则将stack1移入stack2,并将最后一个元素弹出。
(1)弹出时,如果queue1为空,则将queue2的元素依次存入queue1,同时将最后一个元素弹出。同理,
如果queue2为空,则将queue1的元素依次存入queue2,同时将最后一个元素弹出。
(2)存入时,如果queue1和queue2都为空,则任意选择一个存入,如果queue1不为空,则存入queue1.
同理,存入queue2.
两个堆栈实现一个队列思想:
(1)弹出时,如果stack2不为空的话,直接由stack2弹出,如果stack1不为空,则将stack1移入stack2,并将最后一个元素弹出。
(2)存入时,直接将元素存入stack1即可。
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
//两个栈实现一个队列
public class Stack2Queue {
public static void main(String[] args) {
Stack2Queue queue=new Stack2Queue();
List<Integer> re=new ArrayList<Integer>();
queue.add(1);
queue.add(2);
queue.add(3);
re.add(queue.remove());
queue.add(4);
re.add(queue.remove());
queue.add(5);
re.add(queue.remove());
re.add(queue.remove());
re.add(queue.remove());
System.out.println(re.toString());
}
private Stack<Integer> stack1;
private Stack<Integer> stack2;
Stack2Queue() {
stack1 = new Stack<Integer>();
stack2 = new Stack<Integer>(); // 初始化两个栈
}
public Integer remove() {
Integer re = null;
if(!stack2.empty()) {
re = stack2.pop();
} else {
while (!stack1.empty()) {
re = stack1.pop();
stack2.push(re);
}
if(!stack2.empty()){
re = stack2.pop();
}
}
return re;
}
public Integer add(int val){
stack1.push(val);
return val;
}
}
两个队列实现一个堆栈思想:
(1)弹出时,如果queue1为空,则将queue2的元素依次存入queue1,同时将最后一个元素弹出。同理,
如果queue2为空,则将queue1的元素依次存入queue2,同时将最后一个元素弹出。
(2)存入时,如果queue1和queue2都为空,则任意选择一个存入,如果queue1不为空,则存入queue1.
同理,存入queue2.
import java.util.LinkedList;
//用两个队列实现一个栈
public class Queue2Stack {
public static void main(String[] args) {
Queue2Stack stack = new Queue2Stack();
int val = 0;
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);
stack.push(5);
stack.push(6);
val = stack.pop();
System.out.println(val);
val = stack.pop();
System.out.println(val);
val = stack.pop();
System.out.println(val);
val = stack.pop();
System.out.println(val);
val = stack.pop();
System.out.println(val);
val = stack.pop();
System.out.println(val);
}
private LinkedList<Integer> queue1;
private LinkedList<Integer> queue2;
public Queue2Stack() {
queue1=new LinkedList<Integer>();
queue2=new LinkedList<Integer>();
}
public Integer pop() {
Integer re = null;
if (queue1.size() == 0 && queue2.size() == 0) {
return null; // 队列中没有元素
}
if (queue2.size() == 0) {
while (queue1.size() > 0) {
re = queue1.removeFirst();
if (queue1.size() != 0) { // 不要添加最后一个元素给queue2
queue2.addLast(re);
}
}
} else if (queue1.size() == 0) {
while (queue2.size() > 0) {
re = queue2.removeFirst();
if (queue2.size() != 0) {
queue1.addLast(re);
}
}
}
return re;
}
public Integer push(Integer o) {
if (queue1.size() == 0 && queue2.size() == 0) {
queue1.addLast(o); // 这里同样也可以直接添加给queue2
}
if (queue1.size() != 0) {
queue1.addLast(o);
} else if (queue2.size() != 0) {
queue2.addLast(o);
}
return o;
}
}