leetcode(力扣) 54. 螺旋矩阵 （边界控制思路）

题目描述

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]

简化题目

昨天做了一个题跟这个类似，59. 螺旋矩阵 II 虽然这里是螺旋矩阵2，但是我觉得这个题比昨天那个难，建议先做第59题再做这一个。

思路分析

这里我就不说如何循环四条边的思路了，没看过的可以去看一下我昨天发的59题，59. 螺旋矩阵 II

主要说一下这俩题的区别，这道题要处理的情况比上一个多一些，首先就是循环轮数问题，
上一个题给的是正方形，所以循环一定是n//2圈就可以了，
这道题给的是m*n的矩阵，所以循环的轮数是行数和列数中较小的那个除以2，min(len(matrix), len(matrix[0])) // 2:。

上一道题最后只需要看有没有中间值(一个值)需要填充，而这个题由于是矩阵，行数和列数不一定相同，所以有有一行或者一列需要填充，如果行数和列数的最小值为偶数时，则不需要填充，为奇数时则需要填充。

• 列数大于行数 ，则中间有行需要填充。
• 列数小于行数，则中间有列需要填充。
• 两者相等，则中间有一个数需要填充。

在填充的时候没什么好说的，同样起始位置和结束位置是需要变量控制的，不过这里比较容想，稍微几个例子就想通了。

完整代码

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        # matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
        # matrix = [[1,2,3],[4,5,6],[7,8,9]]
        res = []
        if len(matrix[0]) == 1:
            for i in matrix:
                res.extend(i)
            return res
        if len(matrix) ==1 :
            return matrix[0]
        start_x = 0
        start_y = 0
        temp = 1

        n = len(matrix[0])
        for _ in range(min(len(matrix), len(matrix[0])) // 2):
            # 读取最上面一行
            for y in range(start_y, n - temp):
                res.append(matrix[start_x][y])
            # 读取最右边一列
            for x in range(start_x, len(matrix) - temp):
                res.append(matrix[x][n - temp])
            # 读取最下边一行
            for y in range(n - temp, start_y, -1):
                res.append(matrix[len(matrix) - temp][y])
            # 读取最左边一列
            for x in range(len(matrix) - temp, start_x, -1):
                res.append(matrix[x][start_y])
            start_x += 1
            start_y += 1
            temp += 1
        print(res)
        # 中间值处理
        if min(len(matrix), len(matrix[0])) % 2 != 0:
            # 最小值为奇数的情况
            if len(matrix) < len(matrix[0]):
                # 中间行空白    
                for y in range(len(matrix[0]) // 2 - 1, len(matrix[0]) - (len(matrix[0]) // 2 - 1)):
                    res.append(matrix[len(matrix) // 2][y])
            elif len(matrix) > len(matrix[0]):
                # 中间列空白
                for x in range(len(matrix) // 2 - 1, len(matrix) - (len(matrix) // 2 - 1)):
                    res.append(matrix[x][len(matrix[0]) // 2])
            else:
                res.append(matrix[len(matrix) // 2][len(matrix) // 2])

        return res
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

---

时隔两个月二刷

时隔两个月又遇到这个题了，二刷思路改进了一下，之前一刷是用了start_x和start_y来控制起始或结束位置，实际上可以只定义一个start_index变量来操作。

最后填充中间值也精简了一下。

代码:

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        
        row = len(matrix)

        col = len(matrix[0])

        start_index = 0
        res = []
        loop = min(row, col) // 2

        for temp in range(1, loop + 1):
            # 读取最上边一行
            for i in range(start_index, col - temp):
                res.append(matrix[start_index][i])
            # 读取最右边一行
            for i in range(start_index, row - temp):
                res.append(matrix[i][col - temp])
            # 读取最下边一行
            for i in range(col - temp, start_index, -1):
                res.append(matrix[row - temp][i])
            # 读取最左边一行
            for i in range(row - temp, start_index, -1):
                res.append(matrix[i][start_index])
            start_index += 1
        # 填充中间
        # 行大于列，填充列
        if min(row, col) % 2 != 0:
            if row > col:
                for i in range(loop, row - loop):
                    res.append(matrix[i][col // 2])
            # 列大于行，填充行
            elif col > row:
                for i in range(loop, col - loop):
                    res.append(matrix[row // 2][i])
            # 相等且为奇数，填中间一个值
            else:
                res.append(matrix[row // 2][row // 2])
        return res
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

上面代码的for循环里的temp变量实际上就是控制了每条边的结束位置。

最后填充中间值的时候，实际上直接用循环的圈数loop控制就行了，这里稍微想一下就理解了，比较容易。