包含min函数的栈

剑指Offer_21 包含min函数的栈

---

2018/5/22 星期二

题目：定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的min函数。在该栈中，调用min，pop和push的时间复杂度都是O(1)。

分析：我们这里设置一个辅助栈，记录下每次压栈之后，栈中数据元素最小的元素。如下表中所示。

步骤	操作	数据栈	辅助栈	最小值
1	压入3	3	3	3
2	压入4	3,4	3,3	3
3	压入2	3,4,2	3,3,2	2
4	压入1	3,4,2,1	3,3,2,1	1
5	弹出	3,4,2	3,3,2	2
6	弹出	3,4	3,3	3
7	压入0	3,4,0	3,3,0	0

我们每次都把最小元素压入到辅助栈中，那么就可以保证辅助栈的栈顶一直都是最小元素。

参考上面思路：

首先我们定义一个结点用来存储数据结构和引用：

class ListNode<K> {
    K data;
    ListNode<K> nextNode;
}

基于上面结点，设计一个栈的数据结构:

class MyStack<K> {
    public ListNode<K> head;
    public int length;

    public void push(K item) {
        ListNode<K> node = new ListNode<K>();
        node.data = item;
        node.nextNode = head;
        head = node;
        length++;
    }

    public K pop() {
        if (head == null) {
            return null;
        }
        ListNode<K> temp = head;
        head = head.nextNode;
        length--;
        return temp.data;
    }
}

基于基础的MyStack栈的数据结构，增加辅助栈，实现min方法。使得在该栈中，min,push.pop的时间复杂度都是$O(1）$。

class StackWithMin extends MyStack<Integer> {
    private MyStack<Integer> minStack = new MyStack<>();
    private MyStack<Integer> dataStack = new MyStack<>();

    @Override
    public void push(Integer item) {
        dataStack.push(item);
        if (minStack.length == 0 || item <= minStack.head.data) {
            minStack.push(item);
        } else {
            minStack.push(minStack.head.data);
        }
    }

    @Override
    public Integer pop() {
        if (dataStack.length == 0 || minStack.length == 0) {
            return null;
        }
        minStack.pop();
        return dataStack.pop();

    }

    public Integer min() {
        if (minStack.length == 0) {
            return null;
        }
        return minStack.head.data;
    }
}

当然也可以直接采用java.util中自带的Stack对象实现。

public class Main21 {
    Stack<Integer> minStack = new Stack();
    Stack<Integer> dataStack = new Stack();

    Integer pop() {
        if (dataStack.isEmpty()) {
            return null;
        }
        minStack.pop();
        return dataStack.pop();
    }

    void push(Integer item) {
        minStack.push(item);
        if (min() < item || minStack.isEmpty()) {
            dataStack.push(min());
        } else {
            dataStack.push(item);
        }
    }

    Integer min() {
        if (minStack.isEmpty()) {
            return null;
        }
        return dataStack.peek();
    }
}

测试用例：

• 新压入栈的数据比之前最小值大
• 新压入栈的数据比之前最小值小
• 弹出栈的元素不是最小元素
• 弹出栈的元素是最小元素