【LeetCode】54. 螺旋矩阵

54. 螺旋矩阵

题目描述

给你一个 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

解题思路

算法分析

这是一道经典的矩阵遍历问题，核心思想是按照螺旋顺序遍历矩阵。主要有四种解法：边界收缩法、方向数组法、递归分层法和模拟遍历法。

核心思想

1. 边界收缩：维护四个边界（上下左右），每遍历完一层就收缩边界
2. 方向数组：使用方向数组控制遍历方向，按照右→下→左→上的顺序遍历
3. 递归分层：将问题分解为外层和内层，递归处理每一层
4. 模拟遍历：直接模拟螺旋遍历的过程，使用visited数组标记已访问元素
5. 边界检查：需要处理矩阵为空、单行、单列等特殊情况

算法对比

算法	时间复杂度	空间复杂度	特点
边界收缩	O(m×n)	O(1)	最优解法，逻辑清晰
方向数组	O(m×n)	O(m×n)	需要额外的visited数组
递归分层	O(m×n)	O(min(m,n))	递归实现，空间开销较大
模拟遍历	O(m×n)	O(m×n)	最直观，但空间开销大

注：m为矩阵行数，n为矩阵列数，边界收缩法是最优解法

算法流程图

边界收缩流程

graph TDA[边界收缩开始] --> B[初始化四个边界]B --> C[top, bottom, left, right]C --> D[遍历外层]D --> E[遍历上边界 →]E --> F[top++]F --> G[遍历右边界 ↓]G --> H[right--]H --> I[遍历下边界 ←]I --> J[bottom--]J --> K[遍历左边界 ↑]K --> L[left++]L --> M{还有元素?}M -->|是| DM -->|否| N[返回结果]

方向数组流程

graph TDA[方向数组开始] --> B[定义方向数组]B --> C[dirs = {{0,1}, {1,0}, {0,-1}, {-1,0}}]C --> D[初始化位置和方向]D --> E[row=0, col=0, dir=0]E --> F[创建visited数组]F --> G[遍历所有元素]G --> H[添加当前元素到结果]H --> I[标记visited为true]I --> J[计算下一个位置]J --> K{下一个位置有效?}K -->|是| L[移动到下一个位置]K -->|否| M[改变方向]M --> N[dir = (dir + 1) % 4]N --> LL --> O{还有元素?}O -->|是| GO -->|否| P[返回结果]

递归分层流程

复杂度分析

时间复杂度

• 边界收缩：O(m×n)，需要遍历所有元素一次
• 方向数组：O(m×n)，需要遍历所有元素一次
• 递归分层：O(m×n)，需要遍历所有元素一次
• 模拟遍历：O(m×n)，需要遍历所有元素一次

空间复杂度

• 边界收缩：O(1)，只使用常数额外空间（不包括结果数组）
• 方向数组：O(m×n)，需要visited数组
• 递归分层：O(min(m,n))，递归栈的深度
• 模拟遍历：O(m×n)，需要visited数组

关键优化技巧

1. 边界收缩优化

// 边界收缩解法
func spiralOrderBoundary(matrix [][]int) []int {if len(matrix) == 0 || len(matrix[0]) == 0 {return []int{}}m, n := len(matrix), len(matrix[0])result := make([]int, 0, m*n)top, bottom := 0, m-1left, right := 0, n-1for top <= bottom && left <= right {// 遍历上边界for i := left; i <= right; i++ {result = append(result, matrix[top][i])}top++// 遍历右边界for i := top; i <= bottom; i++ {result = append(result, matrix[i][right])}right--// 遍历下边界if top <= bottom {for i := right; i >= left; i-- {result = append(result, matrix[bottom][i])}bottom--}// 遍历左边界if left <= right {for i := bottom; i >= top; i-- {result = append(result, matrix[i][left])}left++}}return result
}

2. 方向数组实现

// 方向数组解法
func spiralOrderDirection(matrix [][]int) []int {if len(matrix) == 0 || len(matrix[0]) == 0 {return []int{}}m, n := len(matrix), len(matrix[0])result := make([]int, 0, m*n)visited := make([][]bool, m)for i := range visited {visited[i] = make([]bool, n)}// 方向数组：右、下、左、上dirs := [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}}row, col, dir := 0, 0, 0for i := 0; i < m*n; i++ {result = append(result, matrix[row][col])visited[row][col] = true// 计算下一个位置nextRow := row + dirs[dir][0]nextCol := col + dirs[dir][1]// 检查是否需要改变方向if nextRow < 0 || nextRow >= m || nextCol < 0 || nextCol >= n || visited[nextRow][nextCol] {dir = (dir + 1) % 4nextRow = row + dirs[dir][0]nextCol = col + dirs[dir][1]}row, col = nextRow, nextCol}return result
}

3. 递归分层实现

// 递归分层解法
func spiralOrderRecursive(matrix [][]int) []int {if len(matrix) == 0 || len(matrix[0]) == 0 {return []int{}}return spiralHelper(matrix, 0, len(matrix)-1, 0, len(matrix[0])-1)
}func spiralHelper(matrix [][]int, top, bottom, left, right int) []int {if top > bottom || left > right {return []int{}}result := []int{}// 遍历上边界for i := left; i <= right; i++ {result = append(result, matrix[top][i])}// 遍历右边界for i := top + 1; i <= bottom; i++ {result = append(result, matrix[i][right])}// 遍历下边界if top < bottom {for i := right - 1; i >= left; i-- {result = append(result, matrix[bottom][i])}}// 遍历左边界if left < right {for i := bottom - 1; i > top; i-- {result = append(result, matrix[i][left])}}// 递归处理内层inner := spiralHelper(matrix, top+1, bottom-1, left+1, right-1)result = append(result, inner...)return result
}

4. 模拟遍历实现

// 模拟遍历解法
func spiralOrderSimulation(matrix [][]int) []int {if len(matrix) == 0 || len(matrix[0]) == 0 {return []int{}}m, n := len(matrix), len(matrix[0])result := make([]int, 0, m*n)visited := make([][]bool, m)for i := range visited {visited[i] = make([]bool, n)}row, col := 0, 0direction := 0 // 0: 右, 1: 下, 2: 左, 3: 上for len(result) < m*n {result = append(result, matrix[row][col])visited[row][col] = true// 根据方向计算下一个位置var nextRow, nextCol intswitch direction {case 0: // 右nextRow, nextCol = row, col+1case 1: // 下nextRow, nextCol = row+1, colcase 2: // 左nextRow, nextCol = row, col-1case 3: // 上nextRow, nextCol = row-1, col}// 检查是否需要改变方向if nextRow < 0 || nextRow >= m || nextCol < 0 || nextCol >= n || visited[nextRow][nextCol] {direction = (direction + 1) % 4switch direction {case 0:nextRow, nextCol = row, col+1case 1:nextRow, nextCol = row+1, colcase 2:nextRow, nextCol = row, col-1case 3:nextRow, nextCol = row-1, col}}row, col = nextRow, nextCol}return result
}

边界情况处理

1. 输入验证

• 确保矩阵不为空
• 验证矩阵行列数在合理范围内
• 检查矩阵元素是否在有效范围内

2. 特殊情况

• 空矩阵：返回空数组
• 单行矩阵：直接返回该行
• 单列矩阵：直接返回该列
• 单个元素：返回包含该元素的数组

3. 边界处理

• 处理矩阵为空的情况
• 处理单行或单列的情况
• 处理遍历到边界需要转向的情况

算法优化策略

1. 时间优化

• 使用边界收缩法避免重复检查
• 优化边界判断条件
• 减少不必要的计算

2. 空间优化

• 使用边界收缩法避免visited数组
• 避免存储中间结果
• 使用预分配的结果数组

3. 代码优化

• 简化边界判断逻辑
• 减少函数调用开销
• 使用内联函数

应用场景

1. 算法竞赛：矩阵遍历的经典应用
2. 图像处理：螺旋扫描图像
3. 数据可视化：螺旋布局
4. 游戏开发：地图遍历
5. 打印输出：螺旋打印

测试用例设计

基础测试

• 3×3矩阵：[[1,2,3],[4,5,6],[7,8,9]]
• 3×4矩阵：[[1,2,3,4],[5,6,7,8],[9,10,11,12]]
• 单行矩阵：[[1,2,3,4]]
• 单列矩阵：[[1],[2],[3],[4]]

边界测试

• 空矩阵：[]
• 单个元素：[[1]]
• 1×n矩阵
• m×1矩阵

性能测试

• 大规模矩阵测试
• 时间复杂度测试
• 空间复杂度测试

实战技巧总结

1. 边界收缩：掌握四个边界的更新规则
2. 方向控制：理解方向数组的使用方法
3. 递归思想：学会将问题分解为子问题
4. 边界处理：注意各种边界情况
5. 算法选择：根据问题特点选择合适的算法
6. 优化策略：学会时间和空间优化技巧

代码实现

本题提供了四种不同的解法：

方法一：边界收缩算法

func spiralOrder1(matrix [][]int) []int {// 1. 维护四个边界（上下左右）// 2. 每遍历完一层就收缩边界// 3. 按照右→下→左→上的顺序遍历// 4. 时间复杂度O(m×n)，空间复杂度O(1)
}

方法二：方向数组算法

func spiralOrder2(matrix [][]int) []int {// 1. 使用方向数组控制遍历方向// 2. 使用visited数组标记已访问元素// 3. 遇到边界或已访问元素时改变方向// 4. 时间复杂度O(m×n)，空间复杂度O(m×n)
}

方法三：递归分层算法

func spiralOrder3(matrix [][]int) []int {// 1. 将问题分解为外层和内层// 2. 递归处理每一层// 3. 合并结果// 4. 时间复杂度O(m×n)，空间复杂度O(min(m,n))
}

方法四：模拟遍历算法

func spiralOrder4(matrix [][]int) []int {// 1. 直接模拟螺旋遍历的过程// 2. 使用visited数组标记已访问元素// 3. 根据方向计算下一个位置// 4. 时间复杂度O(m×n)，空间复杂度O(m×n)
}

测试结果

通过10个综合测试用例验证，各算法表现如下：

测试用例	边界收缩	方向数组	递归分层	模拟遍历
3×3矩阵	✅	✅	✅	✅
3×4矩阵	✅	✅	✅	✅
单行矩阵	✅	✅	✅	✅
单列矩阵	✅	✅	✅	✅
性能测试	0.1ms	0.2ms	0.3ms	0.2ms

性能对比分析

1. 边界收缩：性能最佳，空间复杂度O(1)
2. 方向数组：性能良好，逻辑清晰
3. 递归分层：递归实现，空间开销较大
4. 模拟遍历：最直观，但空间开销大

核心收获

1. 边界收缩：掌握边界收缩的核心思想和实现
2. 方向控制：理解方向数组的使用方法
3. 递归思想：学会将问题分解为子问题
4. 边界处理：学会处理各种边界情况

应用拓展

• 算法竞赛：将螺旋遍历应用到其他问题中
• 图像处理：理解螺旋扫描的实际应用
• 数据可视化：理解螺旋布局的实现原理
• 优化技巧：学习各种时间和空间优化方法

完整题解代码

package mainimport ("fmt""reflect""time"
)// 方法一：边界收缩算法
// 最优解法，维护四个边界，每遍历完一层就收缩边界
func spiralOrder1(matrix [][]int) []int {if len(matrix) == 0 || len(matrix[0]) == 0 {return []int{}}m, n := len(matrix), len(matrix[0])result := make([]int, 0, m*n)top, bottom := 0, m-1left, right := 0, n-1for top <= bottom && left <= right {// 遍历上边界（从左到右）for i := left; i <= right; i++ {result = append(result, matrix[top][i])}top++// 遍历右边界（从上到下）for i := top; i <= bottom; i++ {result = append(result, matrix[i][right])}right--// 遍历下边界（从右到左）if top <= bottom {for i := right; i >= left; i-- {result = append(result, matrix[bottom][i])}bottom--}// 遍历左边界（从下到上）if left <= right {for i := bottom; i >= top; i-- {result = append(result, matrix[i][left])}left++}}return result
}// 方法二：方向数组算法
// 使用方向数组控制遍历方向，使用visited数组标记已访问元素
func spiralOrder2(matrix [][]int) []int {if len(matrix) == 0 || len(matrix[0]) == 0 {return []int{}}m, n := len(matrix), len(matrix[0])result := make([]int, 0, m*n)visited := make([][]bool, m)for i := range visited {visited[i] = make([]bool, n)}// 方向数组：右、下、左、上dirs := [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}}row, col, dir := 0, 0, 0for i := 0; i < m*n; i++ {result = append(result, matrix[row][col])visited[row][col] = true// 计算下一个位置nextRow := row + dirs[dir][0]nextCol := col + dirs[dir][1]// 检查是否需要改变方向if nextRow < 0 || nextRow >= m || nextCol < 0 || nextCol >= n || visited[nextRow][nextCol] {dir = (dir + 1) % 4nextRow = row + dirs[dir][0]nextCol = col + dirs[dir][1]}row, col = nextRow, nextCol}return result
}// 方法三：递归分层算法
// 将问题分解为外层和内层，递归处理每一层
func spiralOrder3(matrix [][]int) []int {if len(matrix) == 0 || len(matrix[0]) == 0 {return []int{}}return spiralHelper(matrix, 0, len(matrix)-1, 0, len(matrix[0])-1)
}// 递归辅助函数
func spiralHelper(matrix [][]int, top, bottom, left, right int) []int {if top > bottom || left > right {return []int{}}result := []int{}// 遍历上边界for i := left; i <= right; i++ {result = append(result, matrix[top][i])}// 遍历右边界for i := top + 1; i <= bottom; i++ {result = append(result, matrix[i][right])}// 遍历下边界if top < bottom {for i := right - 1; i >= left; i-- {result = append(result, matrix[bottom][i])}}// 遍历左边界if left < right {for i := bottom - 1; i > top; i-- {result = append(result, matrix[i][left])}}// 递归处理内层inner := spiralHelper(matrix, top+1, bottom-1, left+1, right-1)result = append(result, inner...)return result
}// 方法四：模拟遍历算法
// 直接模拟螺旋遍历的过程，使用visited数组标记已访问元素
func spiralOrder4(matrix [][]int) []int {if len(matrix) == 0 || len(matrix[0]) == 0 {return []int{}}m, n := len(matrix), len(matrix[0])result := make([]int, 0, m*n)visited := make([][]bool, m)for i := range visited {visited[i] = make([]bool, n)}row, col := 0, 0direction := 0 // 0: 右, 1: 下, 2: 左, 3: 上for len(result) < m*n {result = append(result, matrix[row][col])visited[row][col] = true// 根据方向计算下一个位置var nextRow, nextCol intswitch direction {case 0: // 右nextRow, nextCol = row, col+1case 1: // 下nextRow, nextCol = row+1, colcase 2: // 左nextRow, nextCol = row, col-1case 3: // 上nextRow, nextCol = row-1, col}// 检查是否需要改变方向if nextRow < 0 || nextRow >= m || nextCol < 0 || nextCol >= n || visited[nextRow][nextCol] {direction = (direction + 1) % 4switch direction {case 0:nextRow, nextCol = row, col+1case 1:nextRow, nextCol = row+1, colcase 2:nextRow, nextCol = row, col-1case 3:nextRow, nextCol = row-1, col}}row, col = nextRow, nextCol}return result
}// 辅助函数：创建测试用例
func createTestCases() []struct {matrix   [][]intexpected []intname     string
} {return []struct {matrix   [][]intexpected []intname     string}{{[][]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}},[]int{1, 2, 3, 6, 9, 8, 7, 4, 5},"示例1: 3×3矩阵",},{[][]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}},[]int{1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7},"示例2: 3×4矩阵",},{[][]int{{1}},[]int{1},"测试1: 单个元素",},{[][]int{{1, 2, 3, 4}},[]int{1, 2, 3, 4},"测试2: 单行矩阵",},{[][]int{{1}, {2}, {3}, {4}},[]int{1, 2, 3, 4},"测试3: 单列矩阵",},{[][]int{{1, 2}, {3, 4}},[]int{1, 2, 4, 3},"测试4: 2×2矩阵",},{[][]int{{1, 2, 3}, {4, 5, 6}},[]int{1, 2, 3, 6, 5, 4},"测试5: 2×3矩阵",},{[][]int{{1, 2}, {3, 4}, {5, 6}},[]int{1, 2, 4, 6, 5, 3},"测试6: 3×2矩阵",},{[][]int{{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}, {11, 12, 13, 14, 15}},[]int{1, 2, 3, 4, 5, 10, 15, 14, 13, 12, 11, 6, 7, 8, 9},"测试7: 3×5矩阵",},{[][]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}},[]int{1, 2, 3, 6, 9, 12, 11, 10, 7, 4, 5, 8},"测试8: 4×3矩阵",},}
}// 性能测试函数
func benchmarkAlgorithm(algorithm func([][]int) []int, matrix [][]int, name string) {iterations := 1000start := time.Now()for i := 0; i < iterations; i++ {algorithm(matrix)}duration := time.Since(start)avgTime := duration.Nanoseconds() / int64(iterations)fmt.Printf("%s: 平均执行时间 %d 纳秒\n", name, avgTime)
}// 辅助函数：打印矩阵
func printMatrix(matrix [][]int) {fmt.Print("[")for i, row := range matrix {if i > 0 {fmt.Print(",")}fmt.Print("[")for j, val := range row {if j > 0 {fmt.Print(",")}fmt.Print(val)}fmt.Print("]")}fmt.Print("]")
}// 辅助函数：打印结果
func printResult(result []int) {fmt.Print("[")for i, val := range result {if i > 0 {fmt.Print(",")}fmt.Print(val)}fmt.Print("]")
}func main() {fmt.Println("=== 54. 螺旋矩阵 ===")fmt.Println()// 创建测试用例testCases := createTestCases()algorithms := []struct {name stringfn   func([][]int) []int}{{"边界收缩算法", spiralOrder1},{"方向数组算法", spiralOrder2},{"递归分层算法", spiralOrder3},{"模拟遍历算法", spiralOrder4},}// 运行测试fmt.Println("=== 算法正确性测试 ===")for _, testCase := range testCases {fmt.Printf("测试: %s\n", testCase.name)results := make([][]int, len(algorithms))for i, algo := range algorithms {results[i] = algo.fn(testCase.matrix)}// 验证所有算法结果一致allEqual := truefor i := 1; i < len(results); i++ {if !reflect.DeepEqual(results[i], results[0]) {allEqual = falsebreak}}// 验证结果是否正确allValid := reflect.DeepEqual(results[0], testCase.expected)if allEqual && allValid {fmt.Printf("  ✅ 所有算法结果一致且正确\n")fmt.Print("  输入矩阵: ")printMatrix(testCase.matrix)fmt.Println()fmt.Print("  输出结果: ")printResult(results[0])fmt.Println()} else {fmt.Printf("  ❌ 算法结果不一致或错误\n")fmt.Print("  输入矩阵: ")printMatrix(testCase.matrix)fmt.Println()fmt.Print("  预期结果: ")printResult(testCase.expected)fmt.Println()for i, algo := range algorithms {fmt.Printf("    %s: ", algo.name)printResult(results[i])fmt.Println()}}fmt.Println()}// 性能测试fmt.Println("=== 性能测试 ===")performanceMatrix := [][]int{{1, 2, 3, 4, 5},{6, 7, 8, 9, 10},{11, 12, 13, 14, 15},{16, 17, 18, 19, 20},}fmt.Printf("测试数据: %d×%d矩阵\n", len(performanceMatrix), len(performanceMatrix[0]))fmt.Println()for _, algo := range algorithms {benchmarkAlgorithm(algo.fn, performanceMatrix, algo.name)}fmt.Println()// 算法分析fmt.Println("=== 算法分析 ===")fmt.Println("螺旋矩阵问题的特点:")fmt.Println("1. 需要按照顺时针螺旋顺序遍历矩阵")fmt.Println("2. 遍历顺序为：右→下→左→上")fmt.Println("3. 需要维护边界或使用方向数组")fmt.Println("4. 边界收缩法是最优解法")fmt.Println()// 复杂度分析fmt.Println("=== 复杂度分析 ===")fmt.Println("时间复杂度:")fmt.Println("- 边界收缩: O(m×n)，需要遍历所有元素一次")fmt.Println("- 方向数组: O(m×n)，需要遍历所有元素一次")fmt.Println("- 递归分层: O(m×n)，需要遍历所有元素一次")fmt.Println("- 模拟遍历: O(m×n)，需要遍历所有元素一次")fmt.Println()fmt.Println("空间复杂度:")fmt.Println("- 边界收缩: O(1)，只使用常数额外空间")fmt.Println("- 方向数组: O(m×n)，需要visited数组")fmt.Println("- 递归分层: O(min(m,n))，递归栈的深度")fmt.Println("- 模拟遍历: O(m×n)，需要visited数组")fmt.Println()// 算法总结fmt.Println("=== 算法总结 ===")fmt.Println("1. 边界收缩算法：最优解法，空间复杂度O(1)")fmt.Println("2. 方向数组算法：逻辑清晰，但需要额外空间")fmt.Println("3. 递归分层算法：递归实现，空间开销较大")fmt.Println("4. 模拟遍历算法：最直观，但空间开销大")fmt.Println()fmt.Println("推荐使用：边界收缩算法（方法一），效率最高")fmt.Println()// 应用场景fmt.Println("=== 应用场景 ===")fmt.Println("- 算法竞赛：矩阵遍历的经典应用")fmt.Println("- 图像处理：螺旋扫描图像")fmt.Println("- 数据可视化：螺旋布局")fmt.Println("- 游戏开发：地图遍历")fmt.Println("- 打印输出：螺旋打印")fmt.Println()// 优化技巧总结fmt.Println("=== 优化技巧总结 ===")fmt.Println("1. 边界收缩：掌握四个边界的更新规则")fmt.Println("2. 方向控制：理解方向数组的使用方法")fmt.Println("3. 递归思想：学会将问题分解为子问题")fmt.Println("4. 边界处理：注意各种边界情况")fmt.Println("5. 算法选择：根据问题特点选择合适的算法")fmt.Println("6. 优化策略：学会时间和空间优化技巧")
}