微软面试100题系列---设计包含min函数的栈

题目：设计包含min函数的栈

定义一个栈结构，要求添加一个min函数，得到栈的最小元素；
要求：min函数，push函数，pop函数的时间复杂度为o(1)

实现

方法1

思路：除了题目中要求的栈之外，再创建一个栈（最小栈），用来记录最小值，每当在原栈中push元素时，与最小栈的栈顶元素比较，如果push的值小，则push到最小栈中；否则，将最小栈的栈顶元素再次push到最小栈中；

实现代码：

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class Num2 {

/*
* get the min of stack
*/
public static void main(String[] args) {
MinStack stack=new MinStack();
stack.push(10);
stack.push(2);
stack.push(5);
stack.push(8);
stack.push(11);
System.out.println(stack.min());

stack.pop();
System.out.println(stack.min());

stack.push(1);
System.out.println(stack.min());
}

}
class MinStack{
List <Integer>data=new ArrayList<Integer>();
List<Integer> min=new ArrayList<Integer>();

public void push(int value){
data.add(value);

if(min.size()==0){
min.add(value);
return;
}
int minTop=min.get(min.size()-1);
if(minTop>value){
min.add(value);
}else{
min.add(minTop);
}

}

public  void pop(){
min.remove(min.size()-1);
data.remove(data.size()-1);
}
public int min(){
return min.get(min.size()-1);
}

}

这种方法，空间复杂度o(n)

方法2

思路：

方法1中空间复杂度大，对方法1优化；

一般来说，最小值不会每次都需要更新，因此方法1中的最小值栈中的很多元素是重复的；

优化：向原栈中push新元素时，只有当新元素<=最小栈的栈顶，才向最小栈中push；从原栈中pop时，pop的值等于最小值时，才从最小栈中pop；其他时候不对最小栈pop；

该方法是对方法1中的空间的优化；但空间复杂度仍不是o(1)

实现：

import java.util.ArrayList;
import java.util.List;

public class Num2_2 {

public static void main(String[] args) {
MinStack_2 stack=new MinStack_2();
stack.push(10);
stack.push(2);
stack.push(5);
stack.push(8);
stack.push(11);
System.out.println(stack.min());

stack.pop();
System.out.println(stack.min());

stack.push(1);
System.out.println(stack.min());

}

}

class MinStack_2{
List <Integer>data=new ArrayList<Integer>();
List<Integer> min=new ArrayList<Integer>();

public void push(int value){
data.add(value);

if(min.size()==0){
min.add(value);
return;
}
int minTop=min.get(min.size()-1);
if(minTop>value){
min.add(value);
}
}

public  void pop(){
int topNum=data.get(data.size()-1);
if(topNum==min()){
min.remove(min.size()-1);
}
}
public int min(){
if(min.size()==0){
return Integer.MAX_VALUE;
}
return min.get(min.size()-1);
}
}

方法3

思路：

需要而外一个变量用来保存当前的最小值min；

因为栈中所有元素的值都不会小于当其为栈顶元素时min函数的值，所以在栈中不保存原数据，而是保存原数据比相应最小值大出来的值即可，比如对于元素5,如果以5为栈顶的最小值为3,则push(5)时不是直接存储5,而是存储2(5-3)；

对于最小值更新的位置，栈中应该存储0,但是我们不存储0,而是利用该位置存储–前一个最小值与当前的值的差值；

代码实现：

import java.util.ArrayList;
import java.util.List;

public class Num2_3{

public static void main(String[] args) {
MinStack_3 stack=new MinStack_3();
stack.push(10);
stack.push(2);
stack.push(5);
stack.push(8);
stack.push(11);
System.out.println(stack.min());

stack.pop();
System.out.println(stack.min());

stack.push(1);
System.out.println(stack.min());

}
}

class MinStack_3{
List <Integer>data=new ArrayList<Integer>();
int min=Integer.MAX_VALUE;

public void push(int value){
if(value<this.min){
data.add(min-value);
this.min=value;
}else{
data.add(value-min);
}
}

public  int pop(){
int top=data.get(data.size()-1);
if(top>0){
return top+this.min;
}
this.min=this.min-top;
return this.min;
}
public int min(){
return this.min;
}
}

该方法空间复杂度：o(1)