桟的min实现：O(1)时间复杂度

public class Stack1<Key extends Comparable<Key>> {
    private Node top;
    private Node minTop;

    private class Node {
        Key key;
        Node next;
        Node prev;
        Node(Key key, Node next, Node prev) {
            this.key = key;
            this.next = next;
            this.prev = prev;
        }
    }

    /* 元素入桟,因为要求桟的push,pop以及min操作都为O(1)操作，所以
    *  在元素入桟时还要维护一个min桟 */
    public void push(Key key) {
        if (top == null) {
            top = new Node(key, null, null);
            top.next = null;
            top.prev = null;
            pushMin(key);
            return;
        }

        Node x = new Node(key, null, top);
        top.next = x;
        top = x;
        pushMin(key);
    }

    /* 维护一个最小元素的桟 */
    private void pushMin(Key key) {
        if (minTop == null) {
            minTop = new Node(key, null, null);
            minTop.next = null;
            return;
        }

        if (key.compareTo(minTop.key) < 0) {
            Node x = new Node(key, null, minTop);
            minTop.next = x;
            minTop = x;
        } else {
            Node x = new Node(minTop.key, null, minTop);
            minTop.next = x;
            minTop = x;
        }
    }

    /* 元素出桟，因为要求桟的push,pop以及min操作都为O(1)操作，所以
    *  在元素入桟时还要维护一个min桟 */
    public Key pop() {
        if (top == null) {
            return null;
        }

        Key key = top.key;
        if ((top.prev == null) && (top.next == null)) {
            top = null;
            popMin();
            return key;
        }

        top = top.prev;
        top.next = null;
        popMin();
        return key;
    }

    /* 返回桟中的最小元素 */
    private Key popMin() {
        if (minTop == null) {
            return null;
        }

        Key key = minTop.key;
        if ((minTop.prev == null) && (minTop.next == null)) {
            minTop = null;
            return key;
        }

        minTop = minTop.prev;
        minTop.next = null;
        return minTop.key;
    }

    /* 返回桟的最小元素 */
    public Key min() {
        /* 注意边界条件，当维护的桟为空时minTop也为空 */
        if (minTop == null) {
            return null;
        }
        return minTop.key;
    }

    public static void main(String[] args) {

        Stack1<Integer> stack1 = new Stack1<Integer>();
        stack1.push(11);
        stack1.push(23);
        stack1.push(4);
        stack1.push(76);
        stack1.push(13);
        stack1.push(42);
        System.out.println(stack1.min() + " " + stack1.pop());
        System.out.println(stack1.min() + " " + stack1.pop());
        System.out.println(stack1.min() + " " + stack1.pop());
        System.out.println(stack1.min() + " " + stack1.pop());
        System.out.println(stack1.min() + " " + stack1.pop());
        System.out.println(stack1.min() + " " + stack1.pop());
        System.out.println(stack1.min() + " " + stack1.pop());
    }
}

4 42
4 13
4 76
4 4
11 23
11 11
null null