包含min函数的栈

题目

定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。

解题

方法一：两个栈
一个是普通操作
一个存放最小元素，栈顶始终是最小元素，新入栈元素要与栈顶元素比较后，选取较小的入栈

import java.util.Stack;

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

    public void push(int node) {
        stack.push(node);
        if(minStack.isEmpty()){
            minStack.push(node);
        }else{
            int top = minStack.peek();
            int min = Math.min(top,node);
            minStack.push(min);
        }
    }

    public void pop() {
        if(!stack.isEmpty()){
            stack.pop();
            minStack.pop();
        }
    }

    public int top() {
        if(!stack.isEmpty())
            return stack.peek();
        return -1;
    }

    public int min() {
        if(!minStack.isEmpty())
            return minStack.peek();
        return -1;
    }
}

方法二：一个栈
定义最小栈的数据结构

import java.util.Stack;

class minStack{
    public int node;
    public int min;
    minStack(int node,int min){
        this.node = node;
        this.min = min;
    }
}
public class Solution {
    Stack<minStack> stack = new Stack<minStack>();
    public void push(int node) {
        if(stack.isEmpty()){
            minStack minS = new minStack(node,node);
            stack.push(minS);
        }else{
            minStack minS = stack.peek();
            int tmpMin = minS.min;
            int min = Math.min(node,tmpMin);
            minS = new minStack(node,min);
            stack.push(minS);
        }
    }

    public void pop() {
        if(!stack.isEmpty()){
            stack.pop();

        }
    }

    public int top() {
        if(!stack.isEmpty())
            return stack.peek().node;
        return -1;
    }

    public int min() {
        if(!stack.isEmpty())
            return stack.peek().min;
        return -1;
    }
}