剑指offer——包含min函数的栈（好题！）

面21

题目描述

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

思路：

其实这种面试题还挺常出现的。有读过源码，记得栈的底层数据结构是个数组，但发现用数组实现并不容易，于是想到用list。

一开始用list的错误代码：

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

public class Solution {

ArrayList<Integer> list = new ArrayList<>(100);
int min = Integer.MAX_VALUE;
int last = 0;

public void push(int node) {
list.add(node);
if(node<=min)
min = node;
}

public void pop() {
if(list.size()==0)
return;
list.get(last);
last++;
}

public int top() {
return list.get(last);
}

public int min() {
return min;
}
}

错误原因就在于min函数实现这里，被pop掉的元素仍然参与了min元素的实现过程。所以每次要找到min只能够搜索一遍全栈？（或者维护一个最小堆？）

以及pop也错了。

修改后AC

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

public class Solution {

ArrayList<Integer> list = new ArrayList<>(100);

public void push(int node) {
list.add(node);

}

public void pop() {
if(list.size()==0)
return;
list.remove(list.size()-1);

}

public int top() {
return list.get(list.size()-1);
}

public int min() {
int min = Integer.MAX_VALUE;
for(int i = list.size()-1; i>=0; i--){
if(list.get(i)<=min)
min = list.get(i);
}
return min;

}
}

其他人的解法，时间复杂度更低，不需要遍历求min，当然是空间换时间

import java.util.Stack;
import java.util.Arrays;
public class Solution {
/*借用辅助栈存储min的大小，自定义了栈结构
*/
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始终会存入数据，当node小于min时，存入的是node，并更新min
minStack.push(node);
min = minStack.peek();
}else{ // 当node大于min时，继续存入min
minStack.push(min);
}
//    System.out.println(min+"");
}

private void ensureCapacity(int size) {
// TODO Auto-generated method stub
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();
//    System.out.println(min+"");
}

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;
}
}

minStack和主Stack同步push和pop，两个stack中的数据量始终相同。 minStack的顶部元素始终等于此时主Stack的最小元素。