leetcode——54.螺旋矩阵

思路1：

1. 沿右下左上一次访问矩阵（四个方向）
2. 设立一个visit数组用于记录访问过的元素
3. 当访问路径为矩阵元素的总数则停止访问
4. 对矩阵size为0进行特殊处理，因为后续对order进行内存申请，并不申请为size为0的order

代码1：

class Solution {
private:
    //右 下 左 上
    static constexpr int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        if (matrix.size() == 0 || matrix[0].size() == 0)
            return {};
        //数据初始化
        int rows = matrix.size(), columns = matrix[0].size();
        vector<vector<bool>> visited(rows, vector<bool>(columns));
        int total = rows * columns;
        vector<int> order(total);
		//开始访问
        int row = 0, column = 0;
        int directionIndex = 0;
        for (int i = 0; i < total; i++) {
        	//访问当前元素
            order[i] = matrix[row][column];
            visited[row][column] = true;
            //计算下一个元素位置
            int nextRow = row + directions[directionIndex][0];
            int nextColumn = column + directions[directionIndex][1];
            //判断是否出界或访问过，是的话转弯
            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;
    }
};

思路2：

1. 对矩阵按层循环，每层都走右下左上
2. 需要注意循环条件的约束，还有左上方向的约束
3. 每个for的每个方向都得到达指针位置，即都有“=”，除了上没有

代码2：

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        //特殊处理
        if (matrix.size() == 0 || matrix[0].size() == 0) 
            return {};
        //数组初始化
        int rows = matrix.size(), columns = matrix[0].size();
        vector<int> order;
        int left = 0, right = columns - 1, top = 0, bottom = rows - 1;
        //开始访问
        while (left <= right && top <= bottom) {//这里的等于是为了访问单行/单列的元素
            //向右
            for (int column = left; column <= right; column++) 
                order.push_back(matrix[top][column]);
            //向下
            for (int row = top + 1; row <= bottom; row++) 
                order.push_back(matrix[row][right]);
            if (left < right && top < bottom) {//这里没有等于是因为要转弯
                //向左
                for (int column = right - 1; column >= left; column--)
                    order.push_back(matrix[bottom][column]);
                //向上
                for (int row = bottom-1; row > top; row--) 
                    order.push_back(matrix[row][left]);
            }
            //转更内层
            left++;
            right--;
            top++;
            bottom--;
        }
        return order;
    }
};