第八天《二级指针》_returncolumnsize是不是二级指针-CSDN博客

本文链接：https://blog.csdn.net/songyaxuanwoai/article/details/124533988

文章目录

今日知识总结

二级指针:一个指针引向另一个指针
```
int x = 1;
int *p = &x;
int **q = &p;
```
解引用：二级指针经过一次解引用，变成一级指针，一级指针再进行解引用，变成二级指针

力扣中的二级指针：

int ** func(int ** matrix, int matrixSize, int* matrixColSize, int * returnSize, int ** returnColumnSize){
}
matrix: 传入矩阵的首地址
matrixSize:传入数组的行数
matrixColSize:传入数组每行 的列数
returnSize: 返回数组的行数
returnColumnSize: 返回数组的列数

内存申请模板

int **myMalloc(int r, int c, int* returnSize, int** returnColumnSizes){
    //r表示行数，c表示列数
    int i;
    int **ret = (int**)malloc(sizeof(int*) * r);//申请行的空间
    *returnColumnSizes = (int*)malloc(sizeof(int *) * r);//为矩阵的列申请一个数组来进行记录他每一行的列数
    *returnSize = r;
    for(i = 0; i < r; ++i){
        ret[i] = (int *)malloc(sizeof(int) * c)//申请列的空间
        (*returnColumnSizes)[i] = c;//告诉记录列的数组这行有多少列
    }
    

}

题目分析

832. 翻转图像

题目链接：https://leetcode-cn.com/problems/flipping-an-image/
思路：思路都是一样的，模拟就行，但是c写法中的感觉比较优雅
代码

class Solution {
public:
    vector<vector<int>> flipAndInvertImage(vector<vector<int>>& image) {
        int xlen = image.size();
        int ylen = image[0].size();
        vector<vector<int>> newimage(xlen);
        for(int i = 0; i < xlen; ++i){
            newimage[i].resize(ylen);
        }
        for(int i = 0; i < xlen; ++i){
            for(int j = 0; j < image[0].size(); ++j){
                newimage[i][ylen - j -1] = image[i][j];
                if(newimage[i][xlen - j -1] == 0) newimage[i][xlen - j -1] = 1;
                else if(newimage[i][ylen - j -1] == 1) newimage[i][ylen - j -1] = 0;
            }

        }

        return newimage;


    }
};

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */

int ** myMalloc(int r, int c, int *returnSize, int **returnColumnSizes){
    int i;
    int **ret = (int**)malloc(sizeof(int*) * r);
    *returnColumnSizes = (int*) malloc(sizeof(int*) * r);
    *returnSize = r;
    for(i = 0; i < r; ++i){
        ret[i] = (int *)malloc(sizeof(int) * c);
        (*returnColumnSizes)[i] = c;
    }

    return ret;
}
int** flipAndInvertImage(int** image, int imageSize, int* imageColSize, int* returnSize, int** returnColumnSizes){
    int i, j;
    int r = imageSize, c = imageColSize[0];
    int **ret = myMalloc(r, c, returnSize, returnColumnSizes);
    for(i = 0; i < r; ++i){
        for(j = 0; j < c; ++j){
            ret[i][j] = 1 - image[i][c - j - 1];
        }
    }
    return ret;
}

867. 转置矩阵

题目链接：https://leetcode-cn.com/problems/transpose-matrix/
思路：如果矩阵的某一个位置的位置是 [x, y],那么经过矩阵转置后他的位置和就是 [y, x],那么根据这种规律，我们可以定义一个行数为ylen，列数为xlen的矩阵，遍历原矩阵的每一个数，调转x，y就可以了

代码

class Solution {
public:
    vector<vector<int>> transpose(vector<vector<int>>& matrix) {
        int xlen = matrix.size();
        int ylen = matrix[0].size();
        vector<vector<int>> newimage(ylen);
        for(int i = 0; i < ylen; ++i){
            newimage[i].resize(xlen);
        }
        for(int i = 0; i < xlen; ++i){
            for(int j = 0; j < ylen; ++j){
               newimage[j][i] = matrix[i][j];
                 
            }

        }

        return newimage;



    }
};

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int **myMolloc(int r, int c, int *returnSize,int **returnColumnSizes){
    int **ret = (int**)malloc(sizeof(int*) * r);
    *returnColumnSizes = (int*)malloc(sizeof(int) * r);
    *returnSize = r; 
    for(int i = 0; i < r; ++i){
        ret[i] = (int*) malloc(sizeof(int) * c);
        (*returnColumnSizes)[i] = c;
    }
    return ret;
}

int** transpose(int** matrix, int matrixSize, int* matrixColSize, int* returnSize, int** returnColumnSizes){
    int r = matrixSize, c = matrixColSize[0];
    int ** ret = myMolloc(c, r, returnSize, returnColumnSizes); 
    for(int i = 0; i < r; ++i){
        for(int j = 0; j < c; ++j){
            ret[j][i] = matrix[i][j];
        }
    }
    return ret;

}

566. 重塑矩阵

题目链接：https://leetcode-cn.com/problems/reshape-the-matrix/
思路：首先判断数组个数是否相同，如果相同就按题意进行模拟，c其实就是练习二维数组的模板，思路相差不大，就不再写一遍了

代码：

class Solution {
public:
    vector<vector<int>> matrixReshape(vector<vector<int>>& mat, int r, int c) {
        int xlen = mat.size();
        int ylen = mat[0].size();


        if((xlen * ylen) != (r * c)) return mat;
        vector<vector<int>> ans(r);
        for(int i = 0; i < r; ++i){
            ans[i].resize(c);
        }
        int x = 0, y =0;
        for(int i = 0; i < xlen; ++i){
            for(int j = 0; j < ylen; ++j){
                ans[x][y] = mat[i][j];
                y++;
                if(y >= c) {
                    x++;
                    y = 0;
                }
            }
        } 
        return ans;

    }
};

2022. 将一维数组转变成二维数组

题目链接：https://leetcode-cn.com/problems/convert-1d-array-into-2d-array/
思路：同上题类似

代码：

class Solution {
public:
    vector<vector<int>> construct2DArray(vector<int>& original, int m, int n) {
        int xlen = original.size();
        vector<vector<int>> ans(m);
        
        for(int i = 0; i < m; ++i){
            ans[i].resize(n);
        }
        if(xlen != (m * n)) return {};

        
        
        int x = 0, y =0;
        for(int i = 0; i < xlen; ++i){
                ans[x][y] = original[i];
                y++;
                if(y >= n) {
                    x++;
                    y = 0;
                }
        } 
        return ans;
 

    }
};

今日收获：

指针在32位的操作系统上，占用4个字节
指针在64位的操作系统上，占用8个字节

今日疑问：

为什么返回数组要用二级指针：指针表示的是内存的首地址，二级指针取得是一维指针的首地址，除了列的首地址之外，我们还需要知道每行的列数

vector二维数组的定义

vector<vector<int>> ans(m);
        
        for(int i = 0; i < m; ++i){
            ans[i].resize(n);
        }

返回一个空的二位vector数组
```
return {};
```

第八天《二级指针》

文章目录

文章目录

今日知识总结

题目分析

今日收获：

今日疑问：

资料链接

博客链接