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

#面试题20：顺时针打印矩阵
题目描述：
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵： 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;
        int row = matrix.size();
        if (row == 0)
            return res;
        int col = matrix[0].size();
        int mini = min(row, col);
        int start;
        int end_row = row - 1;
        int end_col = col - 1;
        /* 判断循环终止条件 */
        for (start = 0; start < (mini + 1) / 2; start ++) {
	        /* 一圈分为4步打印，判断边界，是否需要这次打印 */
            if (start <= end_col) {
                for (int i = start; i <= end_col; i ++)
                    res.push_back(matrix[start][i]);
            }
            if (start < end_row) {
                for (int j = start + 1; j <= end_row; j ++)
                    res.push_back(matrix[j][end_col]);
            }
            if (start < end_col && start < end_row) {
                for (int k = end_col - 1; k >= start; k --)
                    res.push_back(matrix[end_row][k]);
            }
            /* 注意这个边界条件 */
            if (start < end_row - 1 && start < end_col) {
                for (int m = end_row - 1; m > start; m --)
                    res.push_back(matrix[m][start]);
            }
         	-- end_row;
            -- end_col;
        }
        return res;
    }
};

关键是细心，别出错。

第二次写这道题：

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> res;
        int row = matrix.size();
        if (row == 0)
            return res;
        int col = matrix[0].size();
        int i, j, endY, endX;
        i = 0;
        endX = col - 1;
        endY = row - 1;
        /* 循环结束条件 */
        while (i < (row + 1) / 2 && i < (col + 1) / 2) {
            for (j = i; j <= endX; j ++)
                res.push_back(matrix[i][j]);
            if (i < endY) {
                for (int k = i + 1; k <= endY; k ++)
                    res.push_back(matrix[k][endX]);
            }
            /* 只有当有第二步时，才会有第三步的 */
            if (i < endY && i < endX) {
                for (int l = endX - 1; l >= i; l --)
                    res.push_back(matrix[endY][l]);
            }
            /* 只有当有第三步时，才会有第四步的 */
            if (i < endY - 1 && i < endX) {
                for (int m = endY - 1; m > i; m --)
                    res.push_back(matrix[m][i]);
            }
            ++ i;
            -- endX;
            -- endY;
        }
        return res;
    }
};

突然觉得原来这道题目考察的是，考虑问题的严谨性的，在开始写代码前注意边界条件，良好编程习惯的重要性，如果写熟练了，出题人的目的就不能达到了。

第三次写这道题：

更喜欢这样的代码，思路一目了然，代码清晰。

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        vector<int> ret;
        int rows = matrix.size();
        if (rows == 0)
            return ret;
        int cols = matrix[0].size();
        int start = 0;
        while (2 * start < cols && 2 * start < rows) {
            printMatrixCircle(matrix, ret, rows, cols, start);
            ++ start;
        }
        return ret;
    }
    void printMatrixCircle(vector<vector<int> > matrix, vector<int> &ret, int rows, int cols, int start) {
        int endx = cols - 1 - start;
        int endy = rows - 1 - start;
        
        for (int i = start; i <= endx; i ++)
            ret.push_back(matrix[start][i]);
        if (start < endy) {
            for (int j = start + 1; j <= endy; j ++)
                ret.push_back(matrix[j][endx]);
        }
        if (start < endy && start < endx)
            for (int k = endx - 1; k >= start; k --)
                ret.push_back(matrix[endy][k]);
        if (start < endx && start < endy - 1)
            for (int m = endy - 1; m >= start + 1; m --)
                ret.push_back(matrix[m][start]);
        
    }
        
};

最后写一次。

vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> ret;
        int rows = matrix.size();
        if (rows == 0)
            return ret;
        int cols = matrix[0].size();
        int circle = (max(rows, cols)+ 1) / 2;
        int i, j, k, l, m;
        for (i = 0; i < circle; i ++) {
            int endx = cols - 1 - i;
            int endy = rows - 1 - i;
            // to right
            for (j = i; j <= endx; j ++) {
                ret.push_back(matrix[i][j]);
            }
            // to down
            if (i < endy) {
                for (k = i + 1; k <= endy; k ++) {
                    ret.push_back(matrix[k][endx]);
                }
            }
            // to left
            if (i < endy && i < endx) {
                for (l = endx - 1; l >= i; l --) {
                    ret.push_back(matrix[endy][l]);
                }
            }
            // to up
            if (i < endy - 1 && i < endx) {
                for (m = endy - 1; m > i; m --) {
                    ret.push_back(matrix[m][i]);
                }
            }
        }
        return ret;
    }