两个队列实现一个栈

无意间看到一个有趣的题目，两个队列实现一个栈。

想了半天，也没有什么优雅的解法，无非是遍历队列取到最后一个值，作为栈的尾巴pop出来。毕竟队列是先进先出的，而栈是后进先出，想要取到队列的最后一个值，必然是要遍历一下的。

代码很简单，就粘贴了。

节点：

    class Node<T> {
        Node<T> next;
        T val;

        Node(T v) {
            val = v;
        }

        @Override
        public String toString() {
            return val + " -> " + next;
        }
    }

队列：

    class Queue<T> {
        Node<T> head;
        int size;

        void enqueue(T val) {
            Node<T> node = new Node<>(val);

            if (head == null) {
                head = node;
            } else {
                Node<T> tail = head;
                while (tail.next != null) {
                    tail = tail.next;
                }
                tail.next = node;
            }
            size++;
        }

        T dequeue() {
            if (head != null) {
                T val = head.val;
                head = head.next;
                size--;
                return val;
            } else {
                throw new NullPointerException();
            }
        }

        int size() {
            return size;
        }

        @Override
        public String toString() {
            return "[" + head + ']';
        }
    }

栈：

    static class Stack<T> {
        Queue<T> q1 = new Queue<>();
        Queue<T> q2 = new Queue<>();
        private int size;

        T pop() {
            if (q1.size() == 0 && q2.size() == 0) {
                return null;
            }
            size--;
            if (q2.size() == 0) {
                while (q1.size() != 1) {
                    T q1Head = q1.dequeue();
                    q2.enqueue(q1Head);
                }
                return q1.dequeue();
            } else {
                while (q2.size() != 1) {
                    T q1Head = q2.dequeue();
                    q1.enqueue(q1Head);
                }
                return q2.dequeue();
            }
        }

        void push(T t) {
            if (q1.size() == 0) {
                q2.enqueue(t);
            } else {
                q1.enqueue(t);
            }
            size++;
        }

        int size() {
            return size;
        }

        @Override
        public String toString() {
            return q1.size() == 0 ? q2.toString() : q1.toString();
        }
    }

测试代码：

    public static void main(String[] args) {
        Queue<Integer> queue = new Queue<>();
        queue.enqueue(1);
        queue.enqueue(2);
        queue.enqueue(3);
        queue.enqueue(4);
        queue.enqueue(5);

        System.out.println("queue0: " + queue);
        int dequeue = queue.dequeue();
        System.out.println("queue1: " + queue + ", deq = " + dequeue);

        Stack<Integer> stack = new Stack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);

        System.out.println("stack0: " + stack);
        int pop = stack.pop();
        System.out.println("stack1: " + stack + ", pop = " + pop);
    }

测试打印结果：

queue0: [1 -> 2 -> 3 -> 4 -> 5 -> null]
queue1: [2 -> 3 -> 4 -> 5 -> null], deq = 1
stack0: [1 -> 2 -> 3 -> 4 -> 5 -> null]
stack1: [1 -> 2 -> 3 -> 4 -> null], pop = 5

可以看到，队列实现了先进先出，栈实现了后进先出，成功。