题目：
给你一个 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]
提示：
m == matrix.length
n == matrix[i].length
1 <= m, n <= 10
-100 <= matrix[i][j] <= 100
解题思路
方法一：模拟
可以模拟螺旋矩阵的路径。初始位置是矩阵的左上角，初始方向是向右，当路径超出界限或者进入之前访问过的位置时，顺时针旋转，进入下一个方向。
判断路径是否进入之前访问过的位置需要使用一个与输入矩阵大小相同的辅助矩阵 \textit{visited}visited，其中的每个元素表示该位置是否被访问过。当一个元素被访问时，将 \textit{visited}visited 中的对应位置的元素设为已访问。
如何判断路径是否结束？由于矩阵中的每个元素都被访问一次，因此路径的长度即为矩阵中的元素数量，当路径的长度达到矩阵中的元素数量时即为完整路径，将该路径返回。
方法一的Golang代码实现
//方法一 模拟
func spiralOrder(matrix [][]int) []int {
rows, columns := len(matrix), len(matrix[0])
totals := rows * columns
visited := make([][]bool, rows)
for i := 0 ;i< rows;i++ {
visited[i] = make([]bool, columns)
}
directions := [][]int{{0,1}, {1,0}, {0,-1}, {-1, 0}} //这是从左上角开始，顺时针旋转时，下标的增量值，所以顺序不能倒
var (
row, column = 0, 0
directionindex = 0
order = make([]int, totals)
)
for i := 0;i< totals;i++{
order[i] = matrix[row][column]
visited[row][column] = true
nextrow, nextcolumn := row + directions[directionindex][0], column + directions[directionindex][1]
//注意此处几项的顺序，visited[nextrow][nextcolumn]必须放在最后，因为要先判断完nextrow,nextcolumn是否合适，才能再判断visited[nextrow][nextcolumn]否则可能越界或者不存在。
if nextrow < 0 ||nextrow >= rows || nextcolumn < 0 || nextcolumn >= columns || visited[nextrow][nextcolumn] {
directionindex = (directionindex + 1 ) % 4
}
row += directions[directionindex][0]
column += directions[directionindex][1]
}
return order
}
方法一的复杂度分析
时间复杂度：O(mn)O(mn)，其中 mm 和 nn 分别是输入矩阵的行数和列数。矩阵中的每个元素都要被访问一次。
空间复杂度：O(mn)O(mn)。需要创建一个大小为 m \times nm×n 的矩阵 \textit{visited}visited 记录每个位置是否被访问过。
方法二：按层模拟
可以将矩阵看成若干层，首先输出最外层的元素，其次输出次外层的元素，直到输出最内层的元素。
定义矩阵的第 kk 层是到最近边界距离为 kk 的所有顶点。例如，下图矩阵最外层元素都是第 11 层，次外层元素都是第 22 层，剩下的元素都是第 33 层。
[[1, 1, 1, 1, 1, 1, 1],
[1, 2, 2, 2, 2, 2, 1],
[1, 2, 3, 3, 3, 2, 1],
[1, 2, 2, 2, 2, 2, 1],
[1, 1, 1, 1, 1, 1, 1]]
对于每层，从左上方开始以顺时针的顺序遍历所有元素。假设当前层的左上角位于 (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 分别增加 11，将 right 和 bottom 分别减少 11，进入下一层继续遍历，直到遍历完所有元素为止。
方法二的Golang代码实现
func spiralOrder(matrix [][]int) []int {
rows, columns := len(matrix), len(matrix[0])
totals := rows * columns
var (
left, right = 0, columns-1
top, bottom = 0, rows-1
order = make([]int, totals)
index = 0
)
for left <= right && top <= bottom {
//从左上到右上
for column := left ;column <= right;column++{
order[index] = matrix[top][column]
index ++
}
//从右上到右下
for row := top + 1; row <= bottom;row++ {
order[index] = matrix[row][right]
index++
}
if left < right && top < bottom {
//从右下到左下
for column := right - 1; column > left;column--{
order[index] = matrix[bottom][column]
index++
}
//从左下到左上
for row := bottom; row > top; row--{
order[index] = matrix[row][left]
index++
}
}
left++
right--
top++
bottom--
}
return order
}
方法二的复杂度分析
复杂度分析
时间复杂度：O(mn)O(mn)，其中 mm 和 nn 分别是输入矩阵的行数和列数。矩阵中的每个元素都要被访问一次。
空间复杂度：O(1)O(1)。除了输出数组以外，空间复杂度是常数。
有疑问加站长微信联系（非本文作者）
