剑指offer——第二十题：包含min函数的栈-优快云博客

本文介绍了一种特殊的数据结构——栈，通过双栈技术实现了O(1)时间复杂度的最小值查询功能。主要讨论了如何在进行常规栈操作的同时，维护一个辅助栈来跟踪并快速获取栈内最小元素，避免了传统方法中需要遍历整个栈的高时间复杂度。

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O(1) ）。

import java.util.Stack;

public class s {
    Stack<Integer> stack = new Stack<>();
    Stack<Integer> stackMin = new Stack<>();

    public void push(int node) {
        stack.push(node);
        if (stackMin.isEmpty()) {
            stackMin.push(node);
        } else {
            stackMin.push(stackMin.peek() > node ? node : stackMin.peek());
        }
    }

    public void pop() {
        stack.pop();
        stackMin.pop();
    }

    public int top() {
        return stack.peek();
    }

    public int min() {
        return stackMin.peek();
    }
}

扩展：采用迭代器（了解即可）

public class o_20 {
    Stack<Integer> stack = new Stack<>();

    public void push(int node) {
        stack.push(node);
    }

    public void pop() {
        stack.pop();
    }

    public int top() {
        return stack.peek();
    }

    public int min() {
        int min = stack.peek();
        int temp = 0;
        Iterator<Integer> it = stack.iterator();
        while (it.hasNext()) {
            temp = it.next();
            if (min > temp) {
                min = temp;
            }
        }
        return min;
    }

关于栈的迭代，如果将1，2，3一次压入栈中，iterator迭代遍历后结果依然是1，2，3的顺序。

    public static void iteratorTest(Stack stack) {
        Iterator<Integer> test = stack.iterator();
        while (test.hasNext()) {
            System.out.println(test.next());
        }
    }

    public static void main(String[] args) {
        Stack<Object> ooo = new Stack<>();
        ooo.push(2);
        ooo.push(4);
        ooo.push(6);
        iteratorTest(ooo);  //2,4,6
    }