【剑指offer】61.顺时针打印矩阵

总目录：

算法之旅导航目录

 

1.问题描述

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

 

2.问题分析

遍历的方向是有顺序的，顺时针意味着右、下、左、上，

延某个方向遍历时终止条件是到达矩阵边界或前方是已经走过的坐标(意味着要维护过去的数据)。

全局终止的条件是到达某个坐标后发现切换各个方向都不能走下一步，则全局结束。

1暴力迭代法

地图走法，硬代码实现问题分析的规则

2层序剥开、收缩边界

不断收缩边界，层序遍历

3.代码实例

暴力迭代法 

class Solution {
  public:
    const int dirCount = 4; //可选方向数量
    const int dirRight = 0, dirDown = 1, dirLeft = 2, dirUp = 3;
    vector<int> printMatrix(vector<vector<int> > matrix) {
        //输入矩阵尺寸校验
        vector<int> ret;
        if (matrix.size() <= 0 || matrix[0].size() <= 0) {
            return ret;
        }
        int rowSize = matrix.size();
        int colSize = matrix[0].size();

        //初始化中间参数
        vector<vector<bool>> passedFlag(rowSize, vector<bool>(colSize, false));
        int curDir = dirRight;
        int curRow = 0, curCol = 0;
        int nextRow = 0, nextCol = 0;
        bool canNext = false;
        int dirWatchDog = 0;//当所有方向都不能继续时触发终止

        //迭代
        while (true) {
            //在当前方向上遍历元素
            while (true) {
                //标记当前坐标
                ret.push_back(matrix[curRow][curCol]);
                passedFlag[curRow][curCol] = true;

                //使用当前方向和坐标获取下一步坐标
                nextRow = curRow;
                nextCol = curCol;
                canNext = getNextStep(curDir, rowSize, colSize, nextRow, nextCol);
                //该方向无下一个坐标
                if (!canNext) {
                    break;
                }
                //该方向上下一个坐标已占用
                if (passedFlag[nextRow][nextCol]) {
                    break;
                }

                //可以切下一步
                curRow = nextRow;
                curCol = nextCol;
            }

            //换到下一个方向
            dirWatchDog = 0; //初始化看门狗
            while (true) {
                //先切到下一个方向
                curDir++;
                dirWatchDog++;//切方向计数

                //检查看门狗溢出
                if (dirWatchDog > dirCount) {
                    return ret;
                }

                //检查该方向是否可行
                if (curDir > dirUp) {
                    curDir = dirRight;
                }
                
                //使用当前方向和坐标获取下一步坐标                
                nextRow = curRow;
                nextCol = curCol;
                canNext = getNextStep(curDir, rowSize, colSize, nextRow, nextCol);
                //该方向无下一个坐标
                if (!canNext) {
                    continue;
                }
                //该方向上下一个坐标已占用
                if (passedFlag[nextRow][nextCol]) {
                    continue;
                }

                //找到了可以继续的方向
                curRow = nextRow;
                curCol = nextCol;
                break;
            }
        }
        return ret;
    }

    //获取指定方向上的下一步坐标
    bool getNextStep(const int dir, const int rowSize, const int colSize,
                     int& rowId,
                     int& colId) {
        switch (dir) {
            case 0:
                if ((colId + 1) >= colSize) {
                    return false;
                }
                colId++;
                break;
            case 1:
                if ((rowId + 1) >= rowSize) {
                    return false;
                }
                rowId++;
                break;
            case 2:
                if ((colId - 1) < 0) {
                    return false;
                }
                colId--;
                break;
            case 3:
                if ((rowId - 1) < 0) {
                    return false;
                }
                rowId--;
                break;
            default:
                return false;
        }
        return true;
    }
};

 收缩边界

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        vector<int> res;
        int n = matrix.size();
        //先排除特殊情况
        if(n == 0) 
            return res;
        //左边界
        int left = 0; 
        //右边界
        int right = matrix[0].size() - 1; 
        //上边界
        int up = 0; 
        //下边界
        int down = n - 1; 
        //直到边界重合
        while(left <= right && up <= down){ 
            //上边界的从左到右
            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;
    }
};