包含min函数的栈、队列

题目：定义栈的数据结构，请在该类型中实现一个能够得到栈/队列的最小元素的min函数。在该栈/队列中，调用min、入栈（入队列）及出栈（出队列）函数的时间复杂度都是O(1)。

1. 包含min函数的栈

　　看到这个问题，第一反应是创建一个成员变量保存栈中当前的最小元素。每次压入一个新元素进栈时，如果该元素比当前最小的元素还要小，则更新最小元素。采用这种思路，元素入栈的时候没有问题，但出栈时如果最小的元素被弹出栈了，就无法得到下一个最小的元素。如图，元素入栈出栈过程如下，当元素3出栈时，无法确定栈中当前最小元素4。

 

元素入栈出栈过程分析

　　分析到这里，我们发现仅仅添加一个成员变量存放最小元素时不够的，也就是当最小元素被弹出栈的时候，我们希望能够得到次小元素。因此，在压入这个最小元素之前，需要把次小元素保存起来，于是采用一个“辅助栈”保存历史最小元素。还是以上面的入栈出栈为例，多了一个辅助栈，当元素3出栈时，依然可以的到栈的当前最小元素。

元素入栈出栈过程分析

算法的代码实现如下：

import java.util.LinkedList;
import java.util.Stack;

public class d30_MinInStack {
    public static void main(String[] args) {
        // 测试包含min函数的栈
        StackWithMin<Integer> stack = new StackWithMin<>();
        stack.push(3);
        stack.push(4);
        stack.push(2);
        stack.pop(); // 当前最小元素出栈，则minStack最小元素也要出栈
        stack.push(0);
        stack.push(-1);
        System.out.println(stack.dataStack); // [3, 4, 0, -1]
        System.out.println(stack.minStack); // [3, 0, -1]
        System.out.println(stack.min()); // -1
    }

    /*
     * 包含min函数的栈
     */
    static class StackWithMin<T extends Comparable<T>> {
        private Stack<T> dataStack; // 记录实际元素的栈
        private Stack<T> minStack; // 记录最小元素的栈

        public StackWithMin() {
            this.dataStack = new Stack<>();
            this.minStack = new Stack<>();
        }

        /*
         * 元素入栈
         */
        public void push(T data) {
            if (data == null) {
                throw new RuntimeException("cannot push null");
            }
            if (dataStack.isEmpty()) {
                dataStack.push(data);
                minStack.push(data);
            } else {
                dataStack.push(data);
                // 记录最小栈的当前最小元素
                T curMin = minStack.peek();
                // 新入栈函数小于curMin
                if (data.compareTo(curMin) < 0) {
                    minStack.push(dataStack.peek());
                }
            }
        }

        /*
         * 元素出栈
         */
        public T pop() {
            if (dataStack.isEmpty()) {
                throw new RuntimeException("dataStack is empty!");
            }
            // 如果出栈元素为dataStack栈的当前最小元素，minStack的栈顶元素出栈
            if (dataStack.peek() == minStack.peek()) {
                minStack.pop();
            }
            return dataStack.pop();
        }

        /*
         * 取栈中最小元素
         */
        public T min() {
            if (minStack.isEmpty()) {
                throw new RuntimeException("minStack is empty!");
            }
            return minStack.peek();
        }
    }
}

2. 包含min函数的队列

　　有了上面对栈的分析作为基础，实现包含min函数的队列就比较容易了。实现思路还是创建“辅助队列”，但与“辅助栈”不同的是，“辅助队列”并不是保存队列中历史最小元素。如果不是最小元素入队列，则“辅助队列”以递减的方式保存元素；如果是最小元素入队列，则“辅助队列”将其他元素出队，只保存该最小元素。具体的过程如下图所示：

元素入队出队过程分析

算法实现代码如下：

import java.util.LinkedList;
import java.util.Stack;

public class d30_MinInStack {

    public static void main(String[] args) {
        // 测试包含min函数的队列
        QueueWithMin<Integer> queue = new QueueWithMin<>();
        queue.enqueue(3);
        queue.enqueue(4);
        queue.enqueue(7);
        System.out.println(queue.min());
        queue.enqueue(5);
        System.out.println();
        System.out.println(queue.min());
    }

    /*
     * 包含min函数的队列
     */
    public static class QueueWithMin<T extends Comparable<T>> {
        private LinkedList<T> dataQueue;
        private LinkedList<T> minQueue;

        public QueueWithMin() {
            dataQueue = new LinkedList<>();
            minQueue = new LinkedList<>();
        }

        // 元素入队
        public void enqueue(T data) {
            if (data == null) {
                throw new RuntimeException("cannot enqueue null");
            }
            dataQueue.offer(data);
            // 保证minQueue队列的元素递减
            // 若data < 队头元素，则minQueue队头元素出队
            while (!minQueue.isEmpty() && (data.compareTo(minQueue.peek()) < 0)) {
                minQueue.poll();
            }
            // 若data < 队尾元素，则minQueue队尾元素出队
           while(!minQueue.isEmpty() && (data.compareTo(minQueue.peekLast()) < 0)) {
                minQueue.poll();
            }
            minQueue.offer(data);
        }

        // 元素出队
        public T dequeue() {
            if (dataQueue.isEmpty()) {
                throw new RuntimeException("dataQueue is empty!");
            }
            // dataQueue出队元素与minQueue队头元素相等，则minQueue队头元素出队
            if (dataQueue.peek() == minQueue.peek()) {
                minQueue.poll();
            }
            return dataQueue.poll();
        }

        // 取队列最小元素
        public T min() {
            if (minQueue.isEmpty()) {
                throw new RuntimeException("minQueue is empty!");
            }
            return minQueue.peek();
        }
    }
}