剑指Offer面试题20顺时针打印矩阵，面试题21包含min函数的栈

面试题20：顺时针打印矩阵

思路：一圈一圈打印，再具体到四个边分别打印。

本题的Java实现：

public class PrintMatrixInCircle {
    public void PrintMatrixClockwisely(int[][] a){
        if (a==null) return;
        int rows=a.length;
        int columns=a[0].length;
        int start=0;//起始位置坐标都是(0,0),(1,1)这种
        while (rows > start*2 && columns > start*2) {
            PrintMatrixInCircle(a,rows,columns,start);//从起始位置开始打印一圈
            start++;
        }
    }
    private void PrintMatrixInCircle(int[][] a, int rows, int columns, int start) {
        int endX=columns-start-1;//这一圈的最后一列的下标
        int endY=rows-start-1;//这一圈的最后一行的下标 
        for (int i = start; i <= endX; i++){//从左到右 打印起始一行
            System.out.println(a[start][i]);
        }
        if (start < endY) {//从上到下 打印列
            for (int i = start+1; i <=endY; i++) {
                System.out.println(a[i][endX]);
            }
        }
        if (start < endX && start < endY) {//从右到左 打印行
            for (int i = endX-1; i >=start; i--) {
                System.out.println(a[endY][i]);
            }
        }
        if (start < endX && start < endY-1) {//从下到上 打印列
            for (int i = endY-1; i >=start+1; i--){
                System.out.println(a[i][start]);
            }
        }
    }
    public static void main(String[] args) {
        int[][] a={
                {1, 2, 3, 4},
                {5, 6, 7, 8},
                {9,10,11,12},
                {13,14,15,16}
        };
        PrintMatrixInCircle t=new PrintMatrixInCircle();
        t.PrintMatrixClockwisely(a);
    }
}

面试题21：包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的Min函数，在该栈中,min,push,pop的时间复杂度都是O(1)。

思路：用两个栈，一个正常处理，另一个存最小值。入栈时，如果值比最小栈栈顶的值小，则入，否则再入一次最小栈栈顶值。每次取min时就取最小栈栈顶。

本题的Java实现：

public class StackWithMin<T>{
	Stack<T> stack = new Stack<>();
	Stack<T> minStack = new Stack<>();
	public void push(T t){
		stack.push(t);
		if(minStack.isEmpty() || (Integer)t < (Integer)minStack.peek()){
			minStack.push(t);
		}else{
			minStack.push(minStack.peek());
		}
	}
	public void pop(){
		if(!stack.isEmpty() && !minStack.isEmpty()){
			stack.pop();
			minStack.pop();	
		}
	}
	public void min(){
		if(!minStack.isEmpty()){
			System.out.println(minStack.peek());
		}
	}
	public static void main(String[] args){
		StackWithMin<Integer> test = new StackWithMin<Integer>();
		test.push(2);
		test.push(2);
		test.push(3);
		test.min();//2
		test.push(1);
		test.min();//1
		test.pop();
		test.min();//2
	}
}