牛客网剑指offer 顺时针打印矩阵

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

对于这道题的提示是：数组的使用，画图让抽象形象化。首先能想到的思路就是顺着题意，由外向内一圈圈地将四条边的数输出，最后保存为一个向量。这个方法需要考虑边界条件，即什么时候停止输出（一共有多少圈则要循环多少次，每次循环都是执行相同的操作：输出四条边）。

根据上面的思路，可以首先写出第一，第二个循环的数据输出情况，再归纳总结出规律，写成加入变量的形式。下面是我从牛客网的讨论区复制的答案。这种方法是最直接的，但是也有一些缺点(难点)，即：1 需要根据矩阵size计算打印圈数, 2 需要根据当前的圈数构造出4个循环来输出四条边，为防止重复输出制定的条件也比较难想。由此可见，如果不想动脑筋寻找更好，更简洁明了的算法，往往要付出复杂的推导或数学计算为代价。

链接：https://www.nowcoder.com/questionTerminal/9b4c81a02cd34f76be2659fa0d54342a
来源：牛客网

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        vector<int>res;
        res.clear();
        int row=matrix.size();//行数
        int collor=matrix[0].size();//列数
        //计算打印的圈数
        // 难点1:circle的计算
        int circle=((row<collor?row:collor)-1)/2+1;//圈数
        for(int i=0;i<circle;i++){
            //从左向右打印
            for(int j=i;j<collor-i;j++)
                res.push_back(matrix[i][j]);         
            //从上往下的每一列数据
            for(int k=i+1;k<row-i;k++)
                res.push_back(matrix[k][collor-1-i]);
            //判断是否会重复打印(从右向左的每行数据)
            // 难点2:需要给出避免重复的条件如row-i-1!=i
            for(int m=collor-i-2;(m>=i)&&(row-i-1!=i);m--)
                res.push_back(matrix[row-i-1][m]);
            //判断是否会重复打印(从下往上的每一列数据)
            for(int n=row-i-2;(n>i)&&(collor-i-1!=i);n--)
                res.push_back(matrix[n][i]);}
        return res;
    }
};

经过一些参考和自己的修改，最后想出了一种自己觉得更好的方法，示意图如下。

这个方法的核心是给定起始列（行）和结束列（行），每一圈顺时针打印完后，使起始列（行）+1，结束列（行）-1，继续顺时针打印本圈，这样最后结束循环的条件就变为：起始行>结束行||起始列>结束列，于是就避免了上面方法的难点1（计算总的圈数）。

这个方法的另外一个思想是对每一圈的输出进行分类：1 本圈只有一行； 2 本圈只有一列； 3 本圈是一个矩阵。

对于前两种情况，很容易进行遍历，一个for循环就可以搞定。

对于第三种情况，依然需要设定四个for循环，但是已经比方法1简单多了，无需设置避免重复打印的条件。具体代码如下：

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        vector<int> vec;
        int r_start=0;
        int r_end=matrix.size()-1;
        int c_start=0;
        int c_end=matrix[0].size()-1;
        int r_count=0;
        int c_count=0;
        if(matrix.size()==0||matrix[0].size()==0)
            return vec;
        //每一圈只会出现三种情况：只有一行，只有一列，一个矩阵
        while(r_start<=r_end&&c_start<=c_end){
            if(r_start==r_end){
                for(c_count=c_start;c_count<=c_end;c_count++)
                    vec.push_back(matrix[r_start][c_count]);
            }
            // 直接输出列
            else if(c_start==c_end){
                for(r_count=r_start;r_count<=r_end;r_count++)
                    vec.push_back(matrix[r_count][c_start]);
            }
            else {
                for(c_count=c_start;c_count<c_end;c_count++)
                    vec.push_back(matrix[r_start][c_count]);
                for(r_count=r_start;r_count<r_end;r_count++)
                    vec.push_back(matrix[r_count][c_end]);
                for(c_count=c_end;c_count>c_start;c_count--)
                    vec.push_back(matrix[r_end][c_count]);
                for(r_count=r_end;r_count>r_start;r_count--)
                    vec.push_back(matrix[r_count][c_start]);
            }
            r_start++;r_end--;
            c_start++;c_end--;
        }
        return vec;
    }
};

注意这道题仍需要细心一点，一些c_start, c_end，r_start，r_end, r_count, c_count还是很容易搞混的。而且结合图更容易想。