每日剑指offer，感谢为秋招努力的自己 2020/7/14

本文链接：https://blog.youkuaiyun.com/weixin_44843571/article/details/107345280

2020.7.14 19：04
19.输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 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.

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        vector<int> res;
        if(matrix.size()==0||matrix[0].size()==0) return res;//注意判空
         int left=0,right=matrix[0].size()-1,up=0,down=matrix.size()-1;
        while(true){//死循环
            for(int i=left;i<=right;i++)
            {
                res.push_back(matrix[up][i]);
            }
            up++;
            if(up>down)
            {
                break;
            }
            for(int i=up;i<=down;i++)
            {
                res.push_back(matrix[i][right]);
            }
            right--;
            if(left>right)
            {
                break;
            }
            for(int i=right;i>=left;i--)
            {
                res.push_back(matrix[down][i]);
            }
            down--;
            if(up>down)
            {
                break;
            }
            for(int i=down;i>=up;i--)
            {
                res.push_back(matrix[i][left]);
            }
            left++;
            if(left>right)
            {
                break;
            }
        }
        return res;
    }
};

这题主要就考验边界问题，只要多做题就大概知道哪里爱出错，就会越来越严谨了
1.判断不要偷懒；
2.死循环和每步跳出收缩边界是关键；

20.定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
注意：保证测试中不会当栈为空的时候，对栈调用pop()或者min()或者top()方法。

提示：使用双栈，辅助栈只存当前最小值

class Solution {
public:
    stack<int>stack1,stack2;//stack1为主栈，stack2为存最小值辅助栈
    void push(int value) {
        stack1.push(value);
        if(stack2.empty())
        {
            stack2.push(value);
        }else{
            if(stack2.top()>=value)//如果新压入数据比top小，则压入数据，反之再压入一次栈顶
            {
                stack2.push(value);
            }else{
                stack2.push(stack2.top());
            }
        }
    }
    void pop() {
        stack1.pop();
        stack2.pop();
    }
    int top() {
        stack1.top();
        stack2.top();
    }
    int min() {
        return stack2.top();
    }
};

21.输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        stack<int> stack1;
        int i=0,j=0;
        while(i<pushV.size())
        {
            if(pushV[i]!=popV[j])
            {
                stack1.push(pushV[i]);
                i++;
            }else{
                i++,j++;//这一步很关键 因为发现相同时候相同的数字并没有入栈
                while(!stack1.empty()&&popV[j]==stack1.top())
                {
                    stack1.pop();
                    j++;
                }
            }
        }
        return stack1.empty();
    }
};

22.从上往下打印出二叉树的每个节点，同层节点从左至右打印。

class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {
        vector<int> res;
        if(!root) return res;//我真是***了 第一个测试用例就是root为空
        queue<TreeNode*> que;//层次遍历用队列
        que.push(root);
        while(!que.empty()){
            TreeNode* tmp=que.front();
            que.pop();
            res.push_back(tmp->val);
            if(tmp->left) que.push(tmp->left);//tmp向下调用 root不变
            if(tmp->right) que.push(tmp->right);
        }
        return res;
    }
};

层次遍历用队列，一层一层入队，一层一层出队
23.输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        if(sequence.size()==0)return false;//空的竟然输出false
        stack<int> stack1;
        int root=INT_MAX;//最开始不设成最大值第一次根的入栈会出错
        for(int i=sequence.size()-1;i>=0;i--)//倒着入栈
        {
            if(sequence[i]>root)
            {
                return false;
            }
            while(!stack1.empty()&&sequence[i]<stack1.top()){//大于堆顶元素 说明到了左右转折点
                root=stack1.top();
                stack1.pop();
            }
            stack1.push(sequence[i]);
        }
        return true;
    }
};