剑指offer面试题29：顺时针打印矩阵

题目描述：输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

示例 1：  输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]         输出：[1,2,3,6,9,8,7,4,5]
示例 2：  输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]     输出：[1,2,3,4,8,12,11,10,9,5,6,7]

题目解析

将矩阵按顺时针从外到内打印一次最外层的“外壳”，将最外层的所有数值打印一次，直到矩阵所有数值打印结束即可。步骤如下：

从左往右打印一行，然后这一行执行完，更新 上边界 向下移动一行
从上往下打印一列，然后这一列执行完，更行 右边界 向左移动一列
从右往左打印一行，然后这一行执行完，更新 下边界 向上移动一行
从下往上打印一列，然后这一列执行完，更行 左边界 向左移动一列
Note： 每一步根据其实 边界值 用一个循环打印出某一行或某一列即可。

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) 
    {
        if(matrix.size() == 0 || matrix[0].size() == 0) return {};
        int left = 0;                      //矩阵的左边界
        int right = matrix[0].size() - 1;  //矩阵的右边界
        int top = 0;                       //矩阵的上边界
        int botton = matrix.size() - 1;    //矩阵的下边界
        vector<int> res;

        while(1)
        {
            //从左往右
            for(int j=left;j<=right;j++)
            {
                res.push_back(matrix[top][j]);
            }
            //上边界下移
            if(++top > botton) break;
            
            //从上往下
            for(int i=top;i<=botton;i++)
            {
                res.push_back(matrix[i][right]);
            }
            //右边界左移
            if(--right < left) break;
            
            //从右往左
            for(int j=right;j>=left;j--)
            {
                res.push_back(matrix[botton][j]);
            }
            //下边界上移
            if(--botton < top) break;
           
            //从下往上
            for(int i=botton;i>=top;i--)
            {
                res.push_back(matrix[i][left]);
            }
            //左边界右移
            if(++left > right) break;
            
        } 
        return res;
    }
};

按层模拟：可以将矩阵看成若干层，首先打印最外层的元素，其次打印次外层的元素，直到打印最内层的元素。

对于每层，从左上方开始以顺时针的顺序遍历所有元素。假设当前层的左上角位于 (top,left)，右下角位于 (bottom,right)，按照如下顺序遍历当前层的元素。

从左到右遍历上侧元素，依次为(top,left) 到 (top,right)。

从上到下遍历右侧元素，依次为 (top+1,right) 到  (bottom,right)。

如果 left<right 且 top<bottom，则从右到左遍历下侧元素，依次为 (bottom,right−1) 到(bottom,left+1)，以及从下到上遍历左侧元素，依次为 (bottom,left) 到 (top+1,left)。

遍历完当前层的元素之后，将 left 和 top 分别增加 1，将 right 和 bottom 分别减少 1，进入下一层继续遍历，直到遍历完所有元素为止。

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) 
    {
        if(matrix.size() == 0 || matrix[0].size() == 0) return {};
        int left = 0;                      //矩阵的左边界
        int right = matrix[0].size() - 1;  //矩阵的右边界
        int top = 0;                       //矩阵的上边界
        int botton = matrix.size() - 1;    //矩阵的下边界
        vector<int> res;

        while(left <= right && top <= botton)
        {
            //从左往右
            for(int j=left;j<=right;j++)
            {
                res.push_back(matrix[top][j]);
            }         
                        
            //从上往下
            for(int i=top+1;i<=botton;i++)
            {
                res.push_back(matrix[i][right]);
            }        
            
            if (left < right && top < botton)
            {
                    //从右往左
                for(int j=right-1;j>left;j--)
                {
                    res.push_back(matrix[botton][j]);
                }
                //从下往上
                for(int i=botton;i>top;i--)
                {
                    res.push_back(matrix[i][left]);
                }
            }
             
            ++top;     //上边界下移    
            --right;   //右边界左移      
            --botton;  //下边界上移
            ++left;    //左边界右移
            
        } 
        return res;
    }
};