mirror of
https://github.com/ShusenTang/LeetCode.git
synced 2024-09-02 14:20:01 +00:00
103 lines
5.1 KiB
Markdown
103 lines
5.1 KiB
Markdown
# [54. Spiral Matrix](https://leetcode.com/problems/spiral-matrix/)
|
||
# 思路
|
||
题目要求顺时针螺旋遍历一个二维数组。
|
||
## 思路一
|
||
根据题意，直接模拟。以遍历一圈为一个循环周期，其中一圈为分为向右、下、左、上遍历。假设二维数组有m行，n列，那么一共有多少圈呢？
|
||
* 如果只看水平方向（向右和向左），因为遍历一圈（最多）需要消耗两行，则需要遍历`(m + 1) / 2`圈；
|
||
* 同理，如果只看垂直方向，则需要遍历`(n + 1) / 2`圈；
|
||
|
||
综合以上两个因素可知一共需要遍历`min((m + 1) / 2, (n + 1) / 2)`圈。
|
||
|
||
循环圈数知道了，那么如何构造每一圈的四个方向呢？假设当前圈的遍历起点为`(i，i)`（行列坐标一定是相等的，想想为什么）:
|
||
* 向右: 行坐标始终是i,而列坐标从`i`到`n - i - 1`(含，下同)；
|
||
* 向下: 列坐标始终是`n - i - 1`，而行坐标从`i + 1`到`m - i - 1`；
|
||
* 向左: 行坐标始终是`m - 1 - i`，而列坐标从`n - 2 - i`到`i`，需要注意的是，此时的行坐标应该大于向右时的行坐标即`m - 1 - i > i`，否则这一行在向右遍历时已经遍历过了，就不需要再遍历了。
|
||
* 向上: 列坐标始终是`i`，行坐标从`m - 2 - i`到`i + 1`，与向左时类似，此时需要满足列坐标小于向下时的列坐标，即`i < n - i - 1`。
|
||
|
||
若n为所有元素个数，则时间复杂度O(n)，空间复杂度为O(1)
|
||
|
||
## 思路二
|
||
思路一就已经很快了，但是需要十分注意一些边界条件，容易出错，而且若想推广到逆时针需要改动很大。下面介绍另外一种好理解且很方便推广到逆时针的方法，来源于[讨论区](https://leetcode.com/problems/spiral-matrix/discuss/20573/A-concise-C%2B%2B-implementation-based-on-Directions)。
|
||
|
||
先来看看这样一个例子:
|
||
```
|
||
1 2 3 4 5
|
||
6 7 8 9 10
|
||
11 12 13 14 15
|
||
```
|
||
还是像思路一一样分成四个方向：向右、向下、向左、向上。那么下面这个例子的遍历过程如下(假设起始行列坐标为(0，-1)):
|
||
* 向右5次；
|
||
* 向下2次；
|
||
* 向左4次；
|
||
* 向上1次；
|
||
* 向右3次；
|
||
* 向下0次，结束。
|
||
|
||
如果我们将向右和向左都看成一个方向（水平），那么此方向移动的次数就是5->4->3；将向下和向上都看做是一个方向（竖直），则移动次数就是2->1->0，所以我们可以发现规律就是水平和竖直两个方向交替移动，每个方向每次的移动步数都是各自递减1的。而水平初始移动次数是n，竖直初始移动次数是m-1，则遍历过程就是:
|
||
1. 水平（向右）移动n次；
|
||
2. 竖直（向下）移动m-1次；
|
||
3. 水平（向左）移动n-1次；
|
||
4. 竖直（向上）移动m-2次；
|
||
5. ......
|
||
|
||
直到移动次数变为0即遍历完成。所以该过程有两个周期，一个是水平与竖直的周期，周期为2；另一个就是具体方向的周期，周期为4。我们可以用一个大小为2的初始值为[n, m-1]的数组steps记录还剩下的两个方向的步数。为了方便四个方向的移动运算，我们可以定义一个二维的const数组dirs，其值为`[[0, 1], [1, 0], [0, -1], [-1, 0]]`。
|
||
|
||
此方法可以很方便地推广到逆时针螺旋遍历，只需要把方向（右、下、左、上）改成（下、右、上、左）即可，即改动一下dirs的元素排列顺序即可。
|
||
|
||
复杂度同思路一。
|
||
|
||
# C++
|
||
## 思路一
|
||
``` C++
|
||
class Solution {
|
||
public:
|
||
vector<int> spiralOrder(vector<vector<int>>& matrix) {
|
||
vector<int>res;
|
||
if(matrix.empty()) return res;
|
||
int m = matrix.size(), n = matrix[0].size();
|
||
for(int i = 0; i < min((m + 1) / 2, (n + 1) / 2); i++){
|
||
for(int j = i; j <= n - i - 1; j++) // 向右
|
||
res.push_back(matrix[i][j]);
|
||
|
||
for(int j = i + 1; j <= m - 1 - i; j++) // 向下
|
||
res.push_back(matrix[j][n - 1 - i]);
|
||
|
||
if(m - 1 - i > i) // 为了避免和向右重复
|
||
for(int j = n - 2 - i; j >= i; j--) // 向左
|
||
res.push_back(matrix[m - 1 - i][j]);
|
||
|
||
if(i < n - 1 - i) // 为了避免和向下重复
|
||
for(int j = m - 2 - i; j >= i + 1; j--) // 向上
|
||
res.push_back(matrix[j][i]);
|
||
}
|
||
return res;
|
||
}
|
||
};
|
||
```
|
||
|
||
## 思路二
|
||
``` C++
|
||
class Solution {
|
||
public:
|
||
vector<int> spiralOrder(vector<vector<int>>& matrix) {
|
||
vector<int>res;
|
||
if(matrix.empty()) return res;
|
||
int m = matrix.size(), n = matrix[0].size();
|
||
const vector<vector<int>>dirs{ {0, 1}, {1, 0}, {0, -1}, {-1, 0} }; // 右、下、左、上
|
||
vector<int>steps{n, m-1};
|
||
|
||
int iDir = 0; // 方向的下标
|
||
int ir = 0, ic = -1; // 初始行列坐标
|
||
while(steps[iDir % 2]){ // 当前是水平or竖直，周期为2
|
||
for(int i = 0; i < steps[iDir % 2]; i++){ // 在当前方向移动steps[iDir % 2]次
|
||
ir += dirs[iDir][0]; ic += dirs[iDir][1];
|
||
res.push_back(matrix[ir][ic]);
|
||
}
|
||
steps[iDir % 2]--;
|
||
iDir = (iDir + 1) % 4; // 下一次的方向，周期为4
|
||
}
|
||
return res;
|
||
}
|
||
};
|
||
```
|