剑指offer - 顺时针打印矩阵

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

解法一：一圈一圈的数（C++）

我们可以用一个循环来打印矩阵，每一次打印矩阵中的一个圈。现在我们来分析循环结束的条件：

假设这个矩阵的行数是rows,列数是columns。打印第一圈的左上角的坐标是(0,0)，第二圈的左上角的坐标是(1,1)，以此类推。我们可以选取矩阵中的左上角为(start,start)的一圈作为我们分析的目标。

对一个5*5的矩阵，最后一圈只有一个数字，对应的坐标为(2,2),我们发现5>2*2。对一个6*6的矩阵而言，最后一圈有4个数字，其左上角的坐标仍然为(2,2)，我们发现6>2*2依然成立。于是我们可以得出，让循环继续的条件是：columns>start*2并且rows>start*2

我们可以将打印一圈分为下面四步：
第一步：从左到右打印一行
第二步：从上到下打印一列
第三步：从右到左打印一行
第四步：从下到上打印一列

但是并不是每一次都要四步走完，所以下面我们来分析每一步的前提条件：

第一步：第一步总是需要的，因为打印一圈至少要有一步。

第二步：如果只有一行的话，那就不需要第二步了。所以需要第二步的前提条件是终止行号大于起始行号的

第三步：需要第三步打印的前提条件是圈内至少有两行两列，即除了要求终止行大于起始行之外，终止列还要大于起始列

第四步：需要打印第四步的前提条件是至少要有三行两列

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> ans;
        if(!matrix.size()) return ans;
        int row = matrix.size();
        int col = matrix[0].size();
        int start = 0;
        while(row>start*2&&col>start*2)
        {
            int end_x = row-1-start;
            int end_y = col-1-start;
            for(int i=start;i<=end_y;i++) ans.push_back(matrix[start][i]);
            if(start<end_x)
            {
                for(int i=start+1;i<=end_x;i++) ans.push_back(matrix[i][end_y]);
            }
            if(start<end_x && start<end_y)
            {
                for(int i=end_y-1;i>=start;i--) ans.push_back(matrix[end_x][i]);
            }
            if(start<end_x-1 && start<end_y)
            {
                for(int i=end_x-1;i>start;i--) ans.push_back(matrix[i][start]);
            }
            start++;
            
        }
        return ans;
    }
};

解法二：Python

不好解释原理，那时溜到起飞

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        ans = []
        while matrix:
            ans += matrix.pop(0)
            matrix = list(zip(*matrix))[::-1]
        return ans

过程解析：

解释两个东西：

• pop(0) 弹出首元素

• zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

  如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
zipped = zip(a,b) # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
zip(a,c) # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
zip(*zipped) # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]