题目：

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

题目示例：

示例 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]

代码：

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        m=len(matrix) #行数
        n=len(matrix[0]) #列数
        juzhen=[[0]*n for _ in range(m)] #创建映射矩阵
        def fangxiang(juzhen,m,n,i,j): #方向控制
            if i!=0 and juzhen[i-1][j]!=1: #向上
                return 1
            elif j!=n-1 and juzhen[i][j+1]!=1: #向右
                return 2
            elif i!=m-1 and juzhen[i+1][j]!=1: #向下
                return 3
            else: #向左
                return 4
        result=[]
        i=0
        j=0
        result.append(matrix[i][j])#初始存
        juzhen[0][0]=1 #初始置0
        while sum(map(sum,juzhen))!=m*n:
            zhuangtai=fangxiang(juzhen,m,n,i,j)
            if zhuangtai==1:#向上进行
                i-=1
                while(i>=0 and juzhen[i][j]==0):
                    result.append(matrix[i][j])
                    juzhen[i][j]=1
                    i-=1 #向上走
                i+=1 #回到最终位置
            elif zhuangtai==2:#向右进行
                j+=1
                while(j<n and juzhen[i][j]==0):
                    result.append(matrix[i][j])
                    juzhen[i][j]=1
                    j+=1 #向右走
                j-=1 #回到最终位置
            elif zhuangtai==3:#向下进行
                i+=1
                while(i<m and juzhen[i][j]==0):
                    result.append(matrix[i][j])
                    juzhen[i][j]=1
                    i+=1 #向下走
                i-=1 #回到最终位置
            elif zhuangtai==4:#向左进行
                j-=1
                while(j>=0 and juzhen[i][j]==0):
                    result.append(matrix[i][j])
                    juzhen[i][j]=1
                    j-=1 #向左走
                j+=1 #回到最终位置
        return result

代码思路：

创建一个对应维度的全0矩阵，走过为1，

通过它来判断上下左右方向，以及是否结束，

结束条件为全0，位置顺序为上下左右

代码逻辑：

juzhen为创建的映射矩阵，

方向函数用来传入当前走的位置以及映射矩阵大小，根据映射矩阵确定待走方向

主函数用来根据映射函数的方向向该方向遍历，将走过的矩阵步数置1，同时将走过的matrix路线保存在结果里，当走到临界点时，循环判断

当映射矩阵全1时说明遍历结束，返回结果

时间复杂度 𝑂(𝑚×𝑛) 空间复杂度𝑂(𝑚×𝑛)