一. 数组_特定顺序遍历二维数组_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]

首先，这个这个需要很多辅助变量的
1.首先初始化一个num，这个的作用是当前行和当前列遍历元素的数量，若是33的矩阵，那么就需要5个位置
2.遍历是肯定是按如下顺序，列+，行+，列-，行-进行，而num矩阵的话，是每次下标移动的数量，那么这样规定了下标变化的范围和那个轴变化，就能得到所有的结果。
3.而且列+的话，就只需要一个for循环即可完成相应的功能。其他的也类似。
4.但这也正是我忽略的地方如果是一个正方形的，那么33：2 2 2 1 1 按照这个数量，肯定没问题。
5.如果是长方形的矩阵就不是了若为3*4，那么每次遍历的数量就没有规律了，我当前这个方法就不行了。
6.当前这个方法是规定走的方向，且规定走几个，方向没问题，但是走几个我现在的方法就不行了。
7.我下面的这个不能通过题解，只有正方形的才可以通过。

vector<int> spiralOrder(vector<vector<int>>& matrix) {
    int row = matrix.size();
    int column = matrix[0].size();
    vector<int> ret(row * column);
    //下面是初始化3 3 3 2 2 1 1，除了第一个数为3个外，其他的数字都为两个
    vector<int> num((row - 1) * 2 + 1);
    num[0] = row - 1;

    for(int i = row - 1, j = 1; i >= 1; i--, j += 2) {
        num[j] = num[j + 1] = i;
    }

    ret[0] = matrix[0][0];   //这里给他初始化一个值
    //当前下标是指示每次访问的数量是多少
    int num_ind = 0;
    //访问的终止下标
    int temp_ind;
    int ret_ind = 0;
    int i = 0, j = 0;

    while(true) {
        temp_ind = j + num[num_ind];

        //列加
        //先用后检查，若检查j==temp_ind则说明已经用过了
        while(j < temp_ind) {
            j++;
            ret_ind++;
            ret[ret_ind] = matrix[i][j];
        }

        //每次都需要检查是否已经遍历完成
        if(num_ind == num.size() - 1) {
            break;
        }

        //每次都需要找到下一个索引和对应的终止索引
        num_ind++;
        temp_ind = i + num[num_ind];

        //行加
        while(i < temp_ind) {
            i++;
            ret_ind++;
            ret[ret_ind] = matrix[i][j];
        }

        if(num_ind == num.size() - 1) {
            break;
        }

        num_ind++;
        temp_ind = j - num[num_ind];

        //列减
        while(j > temp_ind) {
            j--;
            ret_ind++;
            ret[ret_ind] = matrix[i][j];
        }

        if(num_ind == num.size() - 1) {
            break;
        }

        num_ind++;
        temp_ind = i - num[num_ind];

        //行减
        while(i > temp_ind) {
            i--;
            ret_ind++;
            ret[ret_ind] = matrix[i][j];
        }

        num_ind++;

        if(num_ind == num.size() - 1) {
            break;
        }
    }

    return ret;
}

创建数组标识是否访问过，使用一个和matrix同大小的二维数组，若是未访问过则0，访问过则1
1.首先给标记数组初始化为0
2.按照列+，行+，列-，行- 的顺序遍历，使用标识数组标记是否访问过，且使用[0,row]和[0,column]标识是否越界
3.终于这版代码通过了。
4.这里通过模拟点走的方向，其实是在画圆，且不能和之前的重复【使用标识矩阵，标志该元素是否访问过】

vector<int> spiralOrder(vector<vector<int>>& matrix) {
    int m = matrix.size();
    int n = matrix[0].size();
    vector<int> ret(m * n);
    vector<vector<int>> flag(m, vector<int>(n));
    int ret_ind = 0;
    int i = 0, j = 0;

    while(true) {
        //列加
        //先检查是否合法，在使用
        while(j < n  && !flag[i][j]) {
            flag[i][j] = 1;//已经使用了，那么就应该标记为已使用
            ret[ret_ind++] = matrix[i][j++];   //先对原来的位置进行赋值，在将位置向后移动
        }

        if(ret_ind == m * n) {
            break;
        }

        //无论是已经使用或者越界，都需要减去1
        //这里因为若是当前行已经访问过了，那么下次在访问的时候，列的时候当前位置肯定是已经访问过了。
        //为了让程序不中断，每次当前行或当前列遍历结束之后，主动向下走一步，这样永远是没有遍历过的，程序可以继续
        j--;
        i++;

        //行加
        while(i < m && !flag[i][j]) {
            flag[i][j] = 1;
            ret[ret_ind++] = matrix[i++][j];
        }

        if(ret_ind == m * n) {
            break;
        }

        i--;
        j--;

        //列减
        while(j >= 0 && !flag[i][j]) {
            flag[i][j] = 1;
            ret[ret_ind++] = matrix[i][j--];
        }

        if(ret_ind == m * n) {
            break;
        }

        j++;
        i--;

        //行减
        while(i >= 0 && !flag[i][j]) {
            flag[i][j] = 1;
            ret[ret_ind++] = matrix[i--][j];
        }

        if(ret_ind == m * n) {
            break;
        }

        i++;
        j++;
    }

    return ret;
}

上面的方法过于麻烦，但是有解，下面参考官方题解
我认为的是列+，行+，列-，行-，其实可以等同于[0, 1]、[1, 0]、[0, -1]、[-1, 0]对应的坐标加上这个即是
方法还是相同的，只不过坐标变化不用for循环的方式，使用如上的对应坐标加上对应的元素
这里时间复杂度和空间复杂度都是O(mn)

vector<int> spiralOrder(vector<vector<int>>& matrix) {
    //对应下标的方向
    static int dirctions[4][2] = { { 0, 1 }, { 1, 0 }, { 0, -1 }, {-1, 0} };
    int m = matrix.size();
    int n = matrix[0].size();

    if(m == 0 || n == 0) {  //如果该矩阵中没有元素，那么直接返回空列表
        return {};
    }

    vector<int> ret(m * n);
    vector<vector<int>> flag(m, vector<int>(n));
    int i = 0, j = 0;
    int dirc_num = 0; //标识正在那个方向遍历

    //这里首先确定k，而k对应ret的下标
    for(int k = 0; k < m * n; k++) {
        ret[k] = matrix[i][j]; //首先将对应的元素存储
        flag[i][j] = 1;   //说明该元素已经访问过了
        //下面的目标是找到下一个元素的下标
        int n_i = i + dirctions[dirc_num][0];
        int n_j = j + dirctions[dirc_num][1];

        //判断下一个元素的坐标是否合法
        //若合法则说明当前方向需要继续遍历
        if(n_i < m && n_i >= 0 && n_j < n && n_j >= 0 && !flag[n_i][n_j]) { //如果matrix[n_i][n_j]坐标均在范围内，且未被访问过，那么赋值给i，j
            i = n_i;
            j = n_j;
        } else {  //无论当前是已经访问过头了，还是下一个元素已经被访问过了，那就应该在i，j的位置进行下一个方向的变化
            //若不合法，则需要在当前元素的上一个位置进行下一个方向的遍历
            dirc_num = (dirc_num + 1) % 4;
            i += dirctions[dirc_num][0];
            j += dirctions[dirc_num][1];
        }
    }

    return ret;
}

按层遍历
1.可以将矩阵分成若干层，首先按照每层遍历，一层一层的遍历。
2.首先可以确定top、bottom、left、right，每当使用一层这样就调整这四个值
3.每次遍历的顺序都是分别是从(top，left)->(top，right)，之后再从(top+1, right)->(bottom, right)
(bottom，right-1)->(bottom, left)，(bottom-1, left, top+1, left)
4.无论原来的矩阵是什么样子的最后都会成为1 2 3或(1 2 3)^T，1 2; 3 4变成这三种情况，所以这里你只要考虑了所有的情况那么就能实现了。
前两种情况只需要上遍历和右遍历即可
5.官方给的下边界为(bottom, right-1)->(bottom, left+1)，左边界为(bottom, left) -> (top+1, left)

vector<int> spiralOrder(vector<vector<int>>& matrix) {
    int m = matrix.size();
    int n = matrix[0].size();
    int top = 0, bottom = m - 1, left = 0, right = n - 1;   //定义四个边界
    vector<int> ret(m * n);
    int ind = 0;

    //left <= right && top <= bottom使用边界来确定终止条件也是可以的
    while(ind < m * n) {
        //遍历上
        for(int i = left; i <= right; i++) {
            ret[ind++] = matrix[top][i];
        }

        //遍历右
        for(int i = top + 1; i <= bottom; i++) {
            ret[ind++] = matrix[i][right];
        }

        //只有多行且多列才需要下遍历和左遍历
        if(bottom > top && right > left) {
            //遍历下
            for(int i = right - 1; i >= left; i--) {
                ret[ind++] = matrix[bottom][i];
            }

            //遍历左
            for(int i = bottom - 1; i >= top + 1; i--) {
                ret[ind++] = matrix[i][left];
            }
        }

        top++, left++, bottom--, right--;
    }

    return ret;
}

int main() {
    vector<vector<int>>  matrix(2, vector<int>(2));
    matrix[0][0] = 1;
    matrix[0][1] = 2;
    /*
    matrix[0][2] = 3;
    matrix[0][3] = 4;*/
    matrix[1][0] = 5;
    matrix[1][1] = 6;
    /*
    matrix[1][2] = 7;
    matrix[1][3] = 8;*/
    /*
    matrix[2][0] = 9;
    matrix[2][1] = 10;
    matrix[2][2] = 11;
    matrix[2][3] = 12;
    matrix[3][0] = 13;
    matrix[3][1] = 14;
    matrix[3][2] = 15;
    matrix[3][3] = 16;*/
    spiralOrder(matrix);
    return 0;
}