題目及用例

package pid155;
/* 最小棧

設計一個支援 push，pop，top 操作，並能在常數時間內檢索到最小元素的棧。

    push(x) -- 將元素 x 推入棧中。
    pop() -- 刪除棧頂的元素。
    top() -- 獲取棧頂元素。
    getMin() -- 檢索棧中的最小元素。

示例:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.getMin();   --> 返回 -2.




*/




public class main {
	
	public static void main(String[] args) {
		int[][] testTable = {{1,-2,3},{2,7,9,-3,1},{7,10,4,3,1},{11,6,2,7}};
		for (int[] ito : testTable) {
			test(ito);
		}
	}
		 
	private static void test(int[] ito) {
		MinStack solution = new MinStack();
		int rtn;
		long begin = System.currentTimeMillis();
		for (int i = 0; i < ito.length; i++) {
		    System.out.print(ito[i]+" ");
		    solution.push(ito[i]);
		}
		System.out.println();
		//開始時列印陣列
		
		rtn = solution.top();//執行程式
		long end = System.currentTimeMillis();	
		
		System.out.println(": rtn=" +rtn);
		
		
		rtn = solution.getMin();//執行程式
		
		System.out.println(": rtn=" +rtn);
		
		System.out.println();
		System.out.println("耗時：" + (end - begin) + "ms");
		System.out.println("-------------------");
	}

}

 

解法1（成功，115ms，較慢）
由於用常數時間得到最小值，顯然要以空間換時間
設定兩個stack，一個為數的stack，一個為此時min的stack
插入一個數，如果它比min的top都小，則min add 它 否則 add min的top

package pid155;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

class MinStack {

	List<Integer> list;
	List<Integer> minList;
	int length;
	
    /** initialize your data structure here. */
    public MinStack() {
        list=new LinkedList<Integer>();
        minList=new LinkedList<Integer>();
        length=0;
    }
    
    public void push(int x) {
        list.add(x);
        if(length==0){
        	minList.add(x);
        }
        else{
        	if(x<minList.get(length-1)){
        		minList.add(x);
        	}
        	else{
        		minList.add(minList.get(length-1));
        	}
        }
        length++;
    }
    
    public void pop() {
        list.remove(length-1);
        minList.remove(length-1);
        length--;
    }
    
    public int top() {        
    	return list.get(length-1);
    }
    
    public int getMin() {
        
    	return minList.get(length-1);
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */
 

別人的的解法中不用list和linkedlist 而是用java中的stack類

解法2（別人的）
看到這道題我們最容易想到的就是用兩個棧來操作，其中一個輔助棧來存放最小值。但是題目中已經明確說了，設計一個，所以就可以這樣：

在入棧時，如果這個元素比最小值小，那麼，我們讓最小值入棧，然後將元素值賦給最小值，即新的最小值，然後正常將這個元素入棧；在出棧時，如果棧頂元素與最小值相等，說明他的下一個元素是之前push的最小值（上一個），出棧後，將這個之前的最小值賦值給最新的最小值。（每次push進去的最小值都是下面元素的最小值）

class MinStack {
public:
	/** initialize your data structure here. */
	MinStack() {}
	void push(int x) {
		if (minstack.empty())
		{
			minstack.push(x);
			min = x;
		}
		else {
			if (x<=min)//此處必須為<=,否則可以試一下{0，1，0}的情況
			{
				minstack.push(min);
				min = x;
			}
			minstack.push(x);
		}
	}
 
	void pop() {
		if (minstack.empty())return;
		int index = this->top();
		minstack.pop();
		if (min == index && !minstack.empty())
		{
			min = this->top();
			minstack.pop();
		}
	}
 
	int top() {
		return minstack.top();
	}
 
	int getMin() {
		return min;
	}
private:
	int min;
	stack<int>minstack;
};