矩阵螺旋遍历001

1、描述

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

2、关键字

矩阵。遍历
剑指offer同一个题
姐妹篇

3、思路

二维数组遍历，设计一个标记，记录是否遍历过了
然后贪吃蛇一样搞一个蛇头，按当前方向前行，遇到边界就变向
使用宏定义方式更方便阅读
变向时候的边界细节处理，先遍历到边界外，再退回来，换到下一个方向

4、notes

可使用宏定义。
while循环内if-else使用
else if可以不写同一行也行。

5、复杂度

时间：O（NM）
空间：O（NM）

6、code

#define right 1
#define down 2
#define left 3
#define up 0
class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        int n=matrix.size();
        int m=matrix[0].size();
        vector<vector<int>>flag(n,vector<int>(m,0));  // 标记有没有访问过
        int N=n*m;     // 结果个数
        vector<int>res;

        int direct=1;
        int i=0,j=0;
        while(N){
                    if(direct==right && flag[i][j]==0){  // 向右前行
                        res.push_back(matrix[i][j]);
                        N--;
                        flag[i][j]=1;
                        j++;
                        
                        if(j==m || flag[i][j]==1){  // 向下变向
                            direct=down;
                            i++;
                            j--;                          
                        }
                    }else

                    if(direct==down && flag[i][j]==0){  // 向下前行
                        res.push_back(matrix[i][j]);
                        N--;
                        flag[i][j]=1;
                        i++;                   

                        if(i==n || flag[i][j]==1){  // 向左变向
                            direct=left;
                            j--;
                            i--;                        
                        }
                    }else

                    if(direct==left && flag[i][j]==0){  // 前行
                        res.push_back(matrix[i][j]);
                        N--;
                        flag[i][j]=1;
                        j--;
                      
                        if(j==-1 || flag[i][j]==1){  // 变向
                            direct=up;
                            i--;
                            j++;                           
                        }
                    }else
                    
                    if(direct==up && flag[i][j]==0){  前行
                        res.push_back(matrix[i][j]);
                        N--;
                        flag[i][j]=1;
                        i--;
                       
                        if(i==-1 || flag[i][j]==1){  // 变向
                            direct=right;
                            j++;
                            i++;
                        }
                    }
        }
    return res;
    }
};


第二次写：
#define right 1
#define down 2
#define left 3
#define up 0

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int>res;
        int n = matrix.size();
        if(n == 0) return res;  //特判不可少
        int m = matrix[0].size();
        int N = n * m;        
        vector<vector<int>> flag(n,vector<int>(m,0));   // 标志位     
        int direct = right;
        int i = 0, j = 0;
        while(N){
            if(direct == right){
                if(i < n && j < m && flag[i][j] == 0){  // 这里有点不一样，不过结果一样
                    res.push_back(matrix[i][j]);
                    flag[i][j] = 1;
                    j++;
                    N--;                   
                }
                    if(j == m || flag[i][j] == 1){  // 这一块，可以写在上一个if判断的里边
                        direct = down; // 先变向
                        j--;  // 横坐标越界，往左后退一步
                        i++;  // 往下走                        
                    }
               
            }else
            if(direct == down){
                if(i < n && j < m && flag[i][j] == 0){
                    res.push_back(matrix[i][j]);
                    flag[i][j] = 1;
                    i++;
                    N--;
                    
                }
                if(i == n || flag[i][j] == 1){
                        i--;
                        j--;
                        direct = left;
                    }
               
            }else
            if(direct == left){
                if(i >=0 && j >=0 && flag[i][j] == 0){
                    res.push_back(matrix[i][j]);
                    flag[i][j] = 1;
                    j--;
                    N--;
                    
                }
                if(j ==-1 || flag[i][j] == 1){
                        j++;
                        i--;
                        direct = up;
                    }
               
            }else
            if(direct == up){
                if(i >=0 && j >=0 && flag[i][j] == 0){
                    res.push_back(matrix[i][j]);
                    flag[i][j] = 1;
                    i--;
                    N--;
                    
                }
                if(i ==0 || flag[i][j] == 1){
                        j++;
                        i++;
                        direct = right;
                    }
            }
        }
            
        return res;
    }
};