两个栈实现一个队列

两个栈实现一个队列以及两个队列实现一个栈（Java）_java 队列

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<code class="hljs" java="">import java.util.Stack;
 
public class Demo07 {
    Stack<integer> stack1 = new Stack<integer>();
    Stack<integer> stack2 = new Stack<integer>();
 
    public void push(int node) {
        stack1.push(node);
    }
 
    public int pop() {
        if(stack2.size()<=0){
            while(stack1.size()>0){
                /*int data = stack1.peek();//查看栈顶元素，但不移除它
                stack1.pop();//弹出栈顶元素
                stack2.push(data);//压入
                 */                            
                stack2.push(stack1.pop());
            }
        }
 
        if(stack2.isEmpty()){
            try {
                throw new Exception(queue is empty.);
            } catch (Exception e) {
            }
        }
        /**
         * int head = stack2.peek();
         * stack2.pop();
         */
        int head = stack2.pop();
        return head;
 
    }
}
</integer></integer></integer></integer></code>

两个队列实现一个栈

两个栈实现一个队列以及两个队列实现一个栈（Java）_java 队列_02

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
<code class="hljs" cs="">import java.util.ArrayDeque;
import java.util.Queue;
 
public class Demo08 {
    Queue<integer> queue1 = new ArrayDeque<>();
    Queue<integer> queue2 = new ArrayDeque<>();
 
    public void push(int node) {
        //两个栈都为空时，优先考虑queue1
        if (queue1.isEmpty()&&queue2.isEmpty()) {
            queue1.add(node);
            return;
        }
 
        //如果queue1为空，queue2有元素，直接放入queue2
        if (queue1.isEmpty()) {
            queue2.add(node);
            return;
        }
 
        if (queue2.isEmpty()) {
            queue1.add(node);
            return;
        }
 
    }
 
    public int pop() {
        //两个栈都为空时，没有元素可以弹出
        if (queue1.isEmpty()&&queue2.isEmpty()) {
            try {
                throw new Exception(stack is empty);
            } catch (Exception e) {
            }
        }
        //如果queue1为空，queue2有元素， 将queue2的元素依次放入queue1中，直到最后一个元素，我们弹出。
        if (queue1.isEmpty()) {
            while (queue2.size()>1) {
                queue1.add(queue2.poll());
            }
            return queue2.poll();
        }
 
        if (queue2.isEmpty()) {
            while (queue1.size()>1) {
                queue2.add(queue1.poll());
            }
            return queue1.poll();
        }
 
        return (Integer) null;
    }
 
    public static void main(String[] args) {
        Demo08 demo08 = new Demo08();
        demo08.push(1);
        demo08.push(2);
        demo08.push(3);
        demo08.push(4);
        System.out.println(demo08.pop());
        System.out.println(demo08.pop());
        demo08.push(5);
        System.out.println(demo08.pop());
        System.out.println(demo08.pop());
        System.out.println(demo08.pop());
    }
}</integer></integer></code>