数组篇（四）

数组篇（四）

——代码随想录刷题思考及感悟

螺旋矩阵2

59. 螺旋矩阵 II

首先在定义该二维矩阵中通过查找资料在官方文档发现：

vector< vector > v(m, vector(n) )

定义了一个vector容器，元素类型为vector，初始化为包含m个vector对象，每个对象都是一个新创立的vector对象的拷贝，而这个新创立的vector对象被初始化为包含n个0。

因此：从结果上看，类似于创建了一个m×n的二维数组，而且可以通过v[i][j]的方式来访问元素（vector支持下标访问元素）。

思路

这里需要先在纸上或脑海里构建一个上3*3和4*4的矩阵，这是会出现的两种情况，然后我们采用左闭右开的提取方式，这样可以保证每次的循环长度都是固定的。——采取前面二分法提到的，多种循环时要去寻找循环不变量

过程：

1. 分成上下左右四个部分；
2. 在写循环时确定需要的变量——两个二维坐标、圈数、边界宽度、赋值
3. 在模拟循环过程中，找到边界判定——

• 上：i不变，j递增，边界随圈数减少而减2
• 右：j不变，i递增
• 下：i不变，j递减
• 左：j不变，i递减

4. 关键点：

   i < Start_x + n - border
   j < Start_y + n - border
   

5. 循环跳出条件——while循环（当圈数为0即可跳出）

代码：

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> V(n, vector<int>(n));//确定整体阶段为左闭右开
        int Start_x = 0; 
        int Start_y = 0; //定义初始坐标
        int mid = n/2; //定义最中心的点
        int circle = n/2; //定义所绕圈数
        int count = 1; //初始点的值
        int border = 1;
        int i, j;
        while(circle--){
            i = Start_x;
            j = Start_y;
            for(j = Start_y; j < Start_y + n - border ; j++){
                V[Start_x][j] = count ++;
            }
            for(i = Start_x; i < Start_x + n - border; i++){
                V[i][j] = count++; 
            }
            for(j = Start_y + n - border; j > Start_y; j--){
                V[i][j] = count++;
            }
            for(i =  Start_x + n - border; i > Start_x; i--){
                V[i][j] = count++;
            }
            Start_x++;
            Start_y++;
            border += 2;
        }
        if (n%2){
            V[mid][mid] = count;
        }
        return V;
    }
};

衍生题目

螺旋矩阵

54. 螺旋矩阵

这道题是和上一道与之相反的一道，从已经构建好的矩阵中按按顺时针读取，但不相同的是：

该题目中的数字顺序不是顺时针，因此将matrix视作矩阵后，从左至右，依次push_back,由于考虑到不一定是正方矩阵，是M*N的，所以每个循环后都加上一个判断条件——当大于该矩阵长度或宽度时，跳出循环。

注意，当为空矩阵时要单独设出来。

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
    vector<int> v; 
    int n = matrix[0].size();    
    if(matrix.empty()) return v;
    int Stack_x = 0;
    int Stack_y = 0;
    int border_x = matrix.size() - 1;//矩阵的宽度
    int border_y = matrix[0].size() - 1;//矩阵的长度
    int i, j; 
    while(true){
        for(j = Stack_y; j <= border_y; ++j){
            v.push_back(matrix[Stack_x][j]);
        }
        if(++Stack_x > border_x) break;
        for(i = Stack_x; i <= border_x; ++i){
            v.push_back(matrix[i][border_y]);
        }
        if(--border_y < Stack_y) break;
        for(j = border_y; j >= Stack_y; --j){
            v.push_back(matrix[border_x][j]);
        }
        if(--border_x < Stack_x) break;
        for(i = border_x; i >= Stack_x; --i){
            v.push_back(matrix[i][Stack_y]);
        }
        if(++Stack_y > border_y) break;
    }
    return v;
    }
};

根据leetcode题解——这个按层分析，逐层遍历的方法也较为简单
代码：

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; row > top; row--) {
                    order.push_back(matrix[row][left]);
                }
            }
            left++;
            right--;
            top++;
            bottom--;
        }
        return order;
    }
};