剑指offer 19、20、21：顺时针打印矩阵、包含min函数的栈 、栈的压入、弹出序列

第十九题目描述
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.
思路：每一次循环是外侧一圈，那么设置两个标记，每次循环后相当于一个新的矩阵，再次循环。然后分析特殊情况，即只有一行，或一列的数据。

复杂度O(nlogn)
class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        vector<int> data;
        if(matrix.empty())
            return data;
        int rows=matrix.size()-1,row=0;
        int columns=matrix[0].size()-1,column=0;
        while(rows>=row && columns>=column)
        {
            for(int i=column;i<=columns;++i)
            {
                data.push_back(matrix[row][i]);
            }
            for(int i=row+1;i<=rows;++i)
            {
                data.push_back(matrix[i][columns]);
            }
            for(int i=columns-1;row<rows && i>=column;--i)//一行的特殊处理&&
            {
                data.push_back(matrix[rows][i]);
            }
            for(int i=rows-1;column<columns && i>row;--i)//一列的特殊处理&&
            {
                data.push_back(matrix[i][column]);
            }
            ++row;++column;--rows;--columns;//更新标记
        }
        return data;
    }
};

# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表，需要返回列表
    def printMatrix(self, matrix):
        # write code here
        rows=len(matrix)
        if rows==0:
            return
        rows=rows-1
        columns=len(matrix[0])-1
        r0=0
        c0=0
        data=[]
        while rows>=r0 and columns>=c0:
            for i in range(c0,columns+1):
                data.append(matrix[r0][i])
            for i in range(r0+1,rows+1):
                data.append(matrix[i][columns])
            if rows>r0:
                for i in range(c0,columns)[::-1]:
                    data.append(matrix[rows][i])
            if columns>c0:
                for i in range(r0+1,rows)[::-1]:
                    data.append(matrix[i][c0])
            c0+=1
            r0+=1
            columns-=1
            rows-=1
        return data

二十包含min函数的栈
题目描述
定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。
思路：建立辅助空间存储每次增加数据后的最小值
数据 1 2 3 4 0
辅助 1 1 1 1 0 2>1;保存1；0<1 保存0

class Solution {
    stack<int>data;
    stack<int>min_data;
public:
    void push(int value) {
        data.push(value);
        if(!min_data.empty())
            min_data.push(min_data.top()<value? min_data.top() : value);
        else
        min_data.push(value);
        }
    void pop() {
        data.pop();
        min_data.pop();
    }
    int top() {
        return data.top();
    }
    int min() {
        return min_data.top();
    }
};
# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.data=[]
        self.min_data=[]
    def push(self, node):
        self.data.append(node)
        if len(self.min_data)!=0:
            self.min_data.append(min(node,self.min_data[-1]))
        else:
            self.min_data.append(node)
        # write code here
    def pop(self):
        self.data.pop()
        self.min_data.pop()
        # write code here
    def top(self):
        return self.data[-1]
        # write code here
    def min(self):
        return self.min_data[-1]
        # write code here

二十一题题目描述
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4，5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
思路：先入栈，直到与第一个弹出序列数字一样。
1 2 3 ====== 3 5 1 2
1 2 ========5 1 2
入栈
1 2 5 ======5 1 2
1 2 ====1 2
不相等，且已全部入栈。则返回false

class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        if(pushV.empty() || popV.empty() || (pushV.size() != popV.size()))
            return false;
        stack<int>data;
        for(int i=0,j=0;i<pushV.size();++i)
        {
            data.push(pushV[i]);
            while(j<popV.size() && data.top() == popV[j])
            {
                data.pop();
                ++j;
            }
        }
        return data.empty();
    }
};
# -*- coding:utf-8 -*-
class Solution:
    def IsPopOrder(self, pushV, popV):
        if len(pushV)==0 or len(popV)==0 or len(pushV)!=len(popV):
            return False
        j=0
        data=[]
        for i in range(len(pushV)):
            data.append(pushV[i])
            while i>=j and data[-1]==popV[j]:
                data=data[:-1]
                j+=1
        return True if len(data)==0 else False

        # write code here