简单2：螺旋矩阵

 

示例1：

 

思路一：边界模拟法

这道题就是一个简单的模拟，我们想象有一个矩阵，从第一个元素开始，往右到底后再往下到底后再往左到底后再往上，结束这一圈，进入下一圈螺旋。

具体做法:

step 1：首先排除特殊情况，即矩阵为空的情况。

step 2：设置矩阵的四个边界值，开始准备螺旋遍历矩阵，遍历的截止点是左右边界或者上下边界重合。

step 3：首先对最上面一排从左到右进行遍历输出，到达最右边后第一排就输出完了，上边界相应就往下一行，要判断上下边界是否相遇相交。

step 4：然后输出到了右边，正好就对最右边一列从上到下输出，到底后最右边一列已经输出完了，右边界就相应往左一列，要判断左右边界是否相遇相交。

step 5：然后对最下面一排从右到左进行遍历输出，到达最左边后最下一排就输出完了，下边界相应就往上一行，要判断上下边界是否相遇相交。

step 6：然后输出到了左边，正好就对最左边一列从下到上输出，到顶后最左边一列已经输出完了，左边界就相应往右一列，要判断左右边界是否相遇相交。

step 7：重复上述3-6步骤直到循环结束。

 

方法一：

class Solution:

    def spiralOrder(self , matrix ):

        # write code here

        result = [] #返回值

        if matrix == []:

            return []

        # 当二维数组是空或任何一个维度是0，直接返回

        m = len(matrix) #行数

        n = len(matrix[0]) # 列数

        if m == 0 or n == 0:

            return result

        # 二维数组的层数，取决于行和列的较小值

        sizes = (min(m,n)+1)//2

        #大循环，从外向内逐层遍历矩阵

        for i in range(sizes):

            # 从左到右遍历“上边”

            for j in range(i,n-i):

                result.append(matrix[i][j])

            # 从上到下遍历“右边”

            for j in range(i+1,m-i):

                result.append(matrix[j][(n-1)-i])

            # 从右到左遍历“下边”

            for j in range(i+1,n-i):

                #限制条件，因为当遍历内循环时候，四个内循环并不会全部执行

                if (m-1)-i > i:

                    result.append(matrix[m-1-i][n-1-j])

            # 从下到上遍历“左边”

            for j in range(i+1,m-1-i):

                if i < (n-1)-i:

                    result.append(matrix[m-1-j][i])

        return result

        

方法二：

class Solution:

    def spiralOrder(self , matrix: List[List[int]]) -> List[int]:

        res = list()

        n = len(matrix)

        #先排除特殊情况

        if n == 0:

            return res

        #左边界

        left = 0

        #右边界

        right = len(matrix[0]) - 1

        #上边界

        up = 0

        #下边界

        down = n - 1

        #直到边界重合

        while left <= right and up <= down:

            #上边界的从左到右

            for i in range(left, right+1):

                res.append(matrix[up][i])

            #上边界向下

            up += 1

            if up > down:

                break

            #右边界的从上到下

            for i in range(up,down+1):

                res.append(matrix[i][right])

            #右边界向左

            right -= 1

            if left > right:

                break

            i = right

            #下边界的从右到左

            while i >= left:

                res.append(matrix[down][i])

                i -= 1

            #下边界向上

            down -= 1

            if up > down:

                break

            i = down

            #左边界的从下到上

            while i >= up:

                res.append(matrix[i][left])

                i -= 1

            #左边界向右

            left += 1

            if left > right:

                break

        return res

 

思路二：

python的矩阵转置比较简单，也比较好理解：

    将该螺旋矩阵的第一行加到res中，然后去掉矩阵的第一行，将剩下的矩阵转置，再去掉第一行，就像削苹果一样，每转一下，就去掉第一行

class Solution:

    def spiralOrder(self , matrix: List[List[int]]) -> List[int]:

        # write code here

        res = []

        while matrix:

            res += matrix.pop(0)

            matrix = list(zip(*matrix))[::-1]  # 利用zip函数进行操作

        return res

 

参考：

https://www.cnblogs.com/yunhgu/p/13572558.html

https://blog.csdn.net/time_money/article/details/110245204

Zip函数用法：https://blog.csdn.net/qq_29236659/article/details/79772632

Pop函数用法：https://www.cnblogs.com/foremostxl/p/9365482.html

Append函数用法：https://blog.csdn.net/chiyiwei7384/article/details/83988712