剑指Offer-包含min函数的栈Java

20、包含min函数的栈

题目描述：
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
注意：保证测试中不会当栈为空的时候，对栈调用pop()或者min()或者top()方法。

思路：
使用两个栈，其中一个栈用来存储最小元素。栈中元素的进出顺序是固定的，最小元素栈的作用是保证栈顶元素始终是栈中的最小元素。

import java.util.Stack;
import java.util.ArrayList;
public class Solution {
    Stack<Integer> myStack = new Stack<>(), minStack = new Stack<>();
    public void push(int node) {
        myStack.push(node);
        if (minStack.empty()) {//第一个元素入栈
            minStack.push(node);
        }else {
            if(node<minStack.peek()) {//入栈元素值比最小元素值小，更新栈顶值
                minStack.push(node);
            }else {//入栈元素值比最小元素值大，栈顶值依然存入最小值，确保两个栈的元素数量一样
                minStack.push(minStack.peek());
            }
        }
    }
    public void pop() {//两个栈的元素数量一样，出栈的时候直接出栈
        myStack.pop();
        minStack.pop();
    }
    public int top() {//这里究竟是出栈还是返回栈顶元素，题目未明说
        minStack.pop();
        return myStack.pop();
    }
    public int min() {//返回最小元素栈栈顶元素即可
        return minStack.peek();
    }
}

用两个ArrayList实现，思路和用栈是一样的。

import java.util.Stack;
import java.util.ArrayList;
public class Solution {
    ArrayList<Integer> dataList = new ArrayList<>();
    ArrayList<Integer> minList = new ArrayList<>();
    int min = Integer.MAX_VALUE;
    public void push(int node) {
        dataList.add(node);
        if(min>=node){
            min=node;
            minList.add(node);
        }else{
            minList.add(min);
        }
    }
    public int getSize() {
        return dataList.size();
    }
    public void pop() {
        int end = getSize() - 1;
        dataList.remove(end);
        minList.remove(end);
        min = minList.get(getSize() - 1);
    }
    public int top() {
        return dataList.get(getSize() - 1);
    }
    public int min() {
        return min;
    }
}

使用Arrays和最小元素栈，个人感觉比较麻烦，还是ArrayList方便。

import java.util.Stack;
import java.util.Arrays;
public class Solution {
    private int size;
    private int min = Integer.MAX_VALUE;
    private Stack<Integer> minStack = new Stack<Integer>();
    private Integer[] elements = new Integer[10];
    public void push(int node) {
        ensureCapacity(size+1);
        elements[size++] = node;
        if(node <= min){
            minStack.push(node);
            min = minStack.peek();
        }else{
            minStack.push(min);
        }
    }
    private void ensureCapacity(int size) {
        int len = elements.length;
        if(size > len){
            int newLen = (len*3)/2+1; //每次扩容方式
            elements = Arrays.copyOf(elements, newLen);
        }
    }
    public void pop() {
        Integer top = top();
        if(top != null){
            elements[size-1] = (Integer) null;
        }
        size--;
        minStack.pop();    
        min = minStack.peek();
    }
    public int top() {
        if(!empty()){
            if(size-1>=0)
                return elements[size-1];
        }
        return (Integer) null;
    }
    public boolean empty(){
        return size == 0;
    }
    public int min() {
        return min;
    }
}

使用栈和迭代器，时间复杂度不符合题目要求。

import java.util.Stack;
import java.util.Iterator;
public class Solution {
    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 tmp = 0;
        Iterator<Integer> iterator = stack.iterator();
        while (iterator.hasNext()){
            tmp = iterator.next();
            if (min>tmp){
                min = tmp;
            }
        }
        return min;
    }
}

使用ArrayList和Collections，时间复杂度存疑。

import java.util.Stack;
import java.util.ArrayList;
import java.util.Collections;
public class Solution {
    ArrayList<Integer> list1=new ArrayList<Integer>();
    public void push(int node) {
        list1.add(node);
    }
    public void pop() {
        list1.remove(list1.size()-1);
    }
    public int top() {
        return list1.get(list1.size()-1);
    }
    public int min() {
        return Collections.min(list1);
    }
}