[学习报告]《LeetCode零基础指南》(第八讲) 二级指针

爱吃烤秋刀鱼

已于 2022-04-11 19:58:57 修改

阅读量246

点赞数

分类专栏： LeetCode刷题记录文章标签： c语言动态规划 leetcode 算法矩阵

于 2022-04-10 13:59:57 首次发布

本文链接：https://blog.csdn.net/m0_67739923/article/details/124072970

版权

LeetCode刷题记录专栏收录该内容

21 篇文章 0 订阅

订阅专栏

文章目录

一，二级指针介绍
二，做题记录
三，今日收获

一，二级指针介绍

二级指针也是一个指针变量，他与一级指针不同的是一级指针可以指向一个我们已经指定好的变量类型的地址,而二级指针指向的是一个指针变量的地址，也就是说我们对二级指针解引用操作可以得到一个指针变量，再对其解引用可以得到这个指针变量指向的内容，动态开辟一个二维数组就是利用这个方法.

C语言中动态开辟一个二维数组利用的就是二级指针：

void rotate(int** matrix, int matrixSize, int* matrixColSize){
	int ** ans=(int **)malloc(sizeof(int *)*matrisSize);
	int col=matrixColSize[0];
	for(int i=0;i<matrixSize;i++){
		ans[i]=(int*)malloc(sizeof(int)*col);
	}
}

二，做题记录

1.832翻转图像

原题链接

给定一个 n x n 的二进制矩阵 image ，先水平翻转图像，然后反转图像并返回结果。
水平翻转图片就是将图片的每一行都进行翻转，即逆序。
例如，水平翻转 [1,1,0] 的结果是 [0,1,1]。
反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。
例如，反转 [0,1,1] 的结果是 [1,0,0]。
示例 1：
输入：image = [[1,1,0],[1,0,1],[0,0,0]]
输出：[[1,0,0],[0,1,0],[1,1,1]]
解释：首先翻转每一行: [[0,1,1],[1,0,1],[0,0,0]]；
然后反转图片: [[1,0,0],[0,1,0],[1,1,1]]
示例 2：
输入：image = [[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]]
输出：[[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]
解释：首先翻转每一行: [[0,0,1,1],[1,0,0,1],[1,1,1,0],[0,1,0,1]]；
然后反转图片: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]

按照题意对二维数组进行模拟即可，先对行进行反转再取反，这两个过程可以同时进行.
但是同时需要注意到这道题给的参数十分奇怪，他既给了我们原数组的行数和列数，同时也要求我们对返回数组的行数和列数进行赋值，又注意到 $r e t u r n C o l u m n S i z e s$ 给我们的是一个二级指针，也就是说我们只需要对其解引用再将 $i m a g e C o l S i z e$ 赋值给他即可。而 $r e t u r n s i z e$ 就是我们返回数组的行数也就是 $i a m g e s i z e$ ,总的来说对于C语言，这道题给的参数非常奇怪。

/**
 * 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().
 */
void reverse_xor(int ** ans,int ** image ,int row,int col)
{
    for(int i=0;i<row;i++){
        int l=0,r=col-1;
        while(l<=r){
            int tmp=(image[i][l]^1);
            ans[i][l++]=(image[i][r]^1);
            ans[i][r--]=tmp;
        }
    }
}
int** flipAndInvertImage(int** image, int imageSize, int* imageColSize, int* returnSize, int** returnColumnSizes){
    int ** ans=(int**)malloc(sizeof(int*)*imageSize);
    for(int i=0;i<imageSize;i++){
        ans[i]=(int*)malloc(sizeof(int)*imageColSize[0]);
    }
    int row=imageSize,col=imageColSize[0];
    reverse_xor(ans,image,row,col);
    *returnSize=row;
    *returnColumnSizes=imageColSize;
    return ans;
}

在这里插入图片描述

2.867. 转置矩阵

原题链接

给你一个二维整数数组 matrix，返回 matrix 的转置矩阵。
矩阵的转置是指将矩阵的主对角线翻转，交换矩阵的行索引与列索引。
示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[[1,4,7],[2,5,8],[3,6,9]]
示例 2：
输入：matrix = [[1,2,3],[4,5,6]]
输出：[[1,4],[2,5],[3,6]]
提示
m == matrix.length
n == matrix[i].length
1 <= m, n <= 1000
1 <= m * n <= 105
-10^9 <= matrix[i][j] <= 10^9

所谓的矩阵转置就是讲矩阵的每一行按照顺序变成其对应的列即可.

/**
 * 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().
 */
void change(int ** ans,int ** matrix,int row,int col)
{
    for(int i=0;i<row;i++)
    {
        for(int j=0;j<col;j++)
        ans[i][j]=matrix[j][i];
    }
} 
int** transpose(int** matrix, int matrixSize, int* matrixColSize, int* returnSize, int** returnColumnSizes){
    int ** ans=(int**)malloc(sizeof(int*)*matrixColSize[0]);
    int col=matrixSize;
    int row=matrixColSize[0];
    *returnColumnSizes=(int*)malloc(sizeof(int)*row);
    for(int i=0;i<row;i++)
    {
        ans[i]=(int*)malloc(sizeof(int)*col);
       (*returnColumnSizes)[i]=col;
    }
    *returnSize=row;
    change(ans,matrix,row,col);
    return ans;
}

在这里插入图片描述

3.566. 重塑矩阵

原题链接

在 MATLAB 中，有一个非常有用的函数 reshape ，它可以将一个 m x n 矩阵重塑为另一个大小不同（r x c）的新矩阵，但保留其原始数据。
给你一个由二维数组 mat 表示的 m x n 矩阵，以及两个正整数 r 和 c ，分别表示想要的重构的矩阵的行数和列数。
重构后的矩阵需要将原始矩阵的所有元素以相同的行遍历顺序填充。
如果具有给定参数的 reshape 操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。
输入：mat = [[1,2],[3,4]], r = 1, c = 4
输出：[[1,2,3,4]]
输入：mat = [[1,2],[3,4]], r = 2, c = 4
输出：[[1,2],[3,4]]

仍然是按照题目进行模拟即可，但是需要注意过程中的下标关系

 * 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** matrixReshape(int** mat, int matSize, int* matColSize, int r, int c, int* returnSize, int** returnColumnSizes){
    int row=matSize;
    int col=matColSize[0];
    if(row*col!=r*c){
        *returnSize=row;
        *returnColumnSizes=matColSize;
        return mat;
    }
    *returnSize=r;
    *returnColumnSizes=(int*)malloc(sizeof(int)*r);
    int ** ans=(int**)malloc(sizeof(int*)*r);
    for(int i=0;i<r;i++){
        ans[i]=(int*)malloc(sizeof(int)*c);
        (*returnColumnSizes)[i]=c;
    }
    int cnt=0;
    for(int i=0;i<r;i++){
        for(int j=0;j<c;j++){
            ans[i][j]=mat[cnt/col][cnt%col];
            cnt++;//cnt为当前遍历到的原数组的元素个数，初始化为0是为了方便对应下标
            //加入当前遍历了cnt个元素，易知cnt=原数组当前遍历到的行数*原数组的列数+原数组当前行遍历到的列数
            //即使cnt=col*nowrow+nowcol
        }
    }
    return ans;
}

在这里插入图片描述

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

原题链接

给你一个下标从 0 开始的一维整数数组 original 和两个整数 m 和 n 。你需要使用 original 中所有元素创建一个 m 行 n 列的二维数组。
original 中下标从 0 到 n - 1 （都包含）的元素构成二维数组的第一行，下标从 n 到 2 * n - 1 （都包含）的元素构成二维数组的第二行，依此类推。
请你根据上述过程返回一个 m x n 的二维数组。如果无法构成这样的二维数组，请你返回一个空的二维数组。
示例 1：
输入：original = [1,2,3,4], m = 2, n = 2
输出：[[1,2],[3,4]]
解释：
构造出的二维数组应该包含 2 行 2 列。
original 中第一个 n=2 的部分为 [1,2] ，构成二维数组的第一行。
original 中第二个 n=2 的部分为 [3,4] ，构成二维数组的第二行。
示例 2：
输入：original = [1,2,3], m = 1, n = 3
输出：[[1,2,3]]
解释：
构造出的二维数组应该包含 1 行 3 列。
将 original 中所有三个元素放入第一行中，构成要求的二维数组。
示例 3：
输入：original = [1,2], m = 1, n = 1
输出：[]
解释：
original 中有 2 个元素。
无法将 2 个元素放入到一个 1x1 的二维数组中，所以返回一个空的二维数组。
示例 4：
输入：original = [3], m = 1, n = 2
输出：[]
解释：
original 中只有 1 个元素。
无法将 1 个元素放满一个 1x2 的二维数组，所以返回一个空的二维数组。
提示：
1 <= original.length <= 5 * 10^4
1 <= original[i] <= 10^5
1 <= m, n <= 4 * 10^4

和上一题正好是倒过来的操作，如果上一题明白了那么这一题应该会十分简单

/**
 * 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** construct2DArray(int* original, int originalSize, int m, int n, int* returnSize, int** returnColumnSizes){
    if(originalSize!=m*n){
        *returnSize=0;
        return NULL;
    }
    int ** ans=(int**)malloc(sizeof(int*)*m);
    *returnSize=m;
    *returnColumnSizes=(int*)malloc(sizeof(int)*m);
    for(int i=0;i<m;i++){
        ans[i]=(int*)malloc(sizeof(int)*n);
        (*returnColumnSizes)[i]=n;
    }
    int cnt=0;
    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++){
            ans[i][j]=original[cnt++];
        }
    }
    return ans;
}

在这里插入图片描述

5.1260. 二维网格迁移

原题链接给你一个 m 行 n 列的二维网格 grid 和一个整数 k。你需要将 grid 迁移 k 次。
每次「迁移」操作将会引发下述活动：
位于 grid[i][j] 的元素将会移动到 grid[i][j + 1]。
位于 grid[i][n - 1] 的元素将会移动到 grid[i + 1][0]。
位于 grid[m - 1][n - 1] 的元素将会移动到 grid[0][0]。
请你返回 k 次迁移操作后最终得到的二维网格。
示例 1：
输入：grid = [[1,2,3],[4,5,6],[7,8,9]], k = 1
输出：[[9,1,2],[3,4,5],[6,7,8]]
示例 2：
输入：grid = [[3,8,1,9],[19,7,2,5],[4,6,11,10],[12,0,21,13]], k = 4
输出：[[12,0,21,13],[3,8,1,9],[19,7,2,5],[4,6,11,10]]
示例 3：
输入：grid = [[1,2,3],[4,5,6],[7,8,9]], k = 9
输出：[[1,2,3],[4,5,6],[7,8,9]]

这道题有很多很多的方法，比如把二维先铺成一维，然后再通过坐标关系赋值到原数组；也可以每次变换一次直到k次，这里介绍直接通过坐标关系转换的方法.(其实也相当于二维转一维）

/**
 * 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** shiftGrid(int** grid, int gridSize, int* gridColSize, int k, int* returnSize, int** returnColumnSizes){
    int ** ans=(int**)malloc(sizeof(int*)*gridSize);
    *returnColumnSizes=(int*)malloc(sizeof(int)*gridSize);
    *returnSize=gridSize;
    for(int i=0;i<gridSize;i++){
        ans[i]=(int*)malloc(sizeof(int)*gridColSize[0]);
        (*returnColumnSizes)[i]=gridColSize[0];
    }
    int row=gridSize,col=gridColSize[0];
    for(int i=0;i<row;i++){
        for(int j=0;j<col;j++){
            int r=(gridColSize[0]*i+j+k)/gridColSize[0]%gridSize;
            int c=(gridColSize[0]*i+j+k)%gridColSize[0];
            ans[r][c]=grid[i][j];
            //gridColSize[0]*i+j+k就是吧原二维数组展开成一维数组，现在遍历到的数移动k次后的位置
            //将其除以列数得到的是行数，由于最后的k个数移动k次后要超过数组元素个数所以要模上数组个数
            //公式的话跟上题类似不再赘述
        }
    }
    return ans;
}

在这里插入图片描述

6.661. 图片平滑器

原题链接

像平滑器是大小为 3 x 3 的过滤器，用于对图像的每个单元格平滑处理，平滑处理后单元格的值为该单元格的平均灰度。
每个单元格的平均灰度定义为：该单元格自身及其周围的 8 个单元格的平均值，结果需向下取整。（即，需要计算蓝色平滑器中 9 个单元格的平均值）。
如果一个单元格周围存在单元格缺失的情况，则计算平均灰度时不考虑缺失的单元格（即，需要计算红色平滑器中 4 个单元格的平均值）。
给你一个表示图像灰度的 m x n 整数矩阵 img ，返回对图像的每个单元格平滑处理后的图像。
示例 1:
输入:img = [[1,1,1],[1,0,1],[1,1,1]]
输出:[[0, 0, 0],[0, 0, 0], [0, 0, 0]]
解释:
对于点 (0,0), (0,2), (2,0), (2,2): 平均(3/4) = 平均(0.75) = 0
对于点 (0,1), (1,0), (1,2), (2,1): 平均(5/6) = 平均(0.83333333) = 0
对于点 (1,1): 平均(8/9) = 平均(0.88888889) = 0
示例 2:
输入: img = [[100,200,100],[200,50,200],[100,200,100]]
输出: [[137,141,137],[141,138,141],[137,141,137]]
解释:
对于点 (0,0), (0,2), (2,0), (2,2): floor((100+200+200+50)/4) = floor(137.5) = 137
对于点 (0,1), (1,0), (1,2), (2,1): floor((200+200+50+200+100+100)/6) = floor(141.666667) = 141
对于点 (1,1): floor((50+200+200+200+200+100+100+100+100)/9) = floor(138.888889) = 138
提示:
m == img.length
n == img[i].length
1 <= m, n <= 200
0 <= img[i][j] <= 255

这道题跟昨天的最后一题十分类似，也是简单的搜索题，不同的是这个题从四个方向变成了八个方向。

/**
 * 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 dir[8][2]={{0,1},{0,-1},{1,1},{1,-1},{-1,1},{-1,-1},{1,0},{-1,0}};
int** imageSmoother(int** img, int imgSize, int* imgColSize, int* returnSize, int** returnColumnSizes){
    int row=imgSize,col=imgColSize[0];
    int ** ans=(int*)malloc(sizeof(int*)*row);
    (*returnColumnSizes)=(int*)malloc(sizeof(int)*row);
    *returnSize=row;
    for(int i=0;i<row;i++){
        ans[i]=(int*)malloc(sizeof(int)*col);
        (*returnColumnSizes)[i]=col;
    }
    int sum=0,cnt=0;
    int tx,ty;
    for(int i=0;i<row;i++){
        for(int j=0;j<col;j++){
            sum=img[i][j],cnt=1;
            for(int k=0;k<8;k++){
                tx=i+dir[k][0];
                ty=j+dir[k][1];
                if(tx==-1||ty==-1||tx==row||ty==col){
                    continue;
                }
                sum+=img[tx][ty];
                cnt++;
            }
            ans[i][j]=sum/cnt;
        }
    }
    return ans;
}

在这里插入图片描述

7.1314.矩阵区域和

原题链接

给你一个 m x n 的矩阵 mat 和一个整数 k ，请你返回一个矩阵 answer ，其中每个 answer[i][j] 是所有满足下述条件的元素 mat[r][c] 的和：
i - k <= r <= i + k,
j - k <= c <= j + k 且
(r, c) 在矩阵内。
示例 1：
输入：mat = [[1,2,3],[4,5,6],[7,8,9]], k = 1
输出：[[12,21,16],[27,45,33],[24,39,28]]
示例 2：
输入：mat = [[1,2,3],[4,5,6],[7,8,9]], k = 2
输出：[[45,45,45],[45,45,45],[45,45,45]]
提示：
m == mat.length
n == mat[i].length
1 <= m, n, k <= 100
1 <= mat[i][j] <= 100

这道题暴力过法十分简单，遍历每一个元素的时候去累加即可，这里介绍一种进阶解法利用二维前缀和.关于二维前缀和的讲解可以自行搜索，其实不难理解。这里简单的说一下,首先我们定义一个二维数组来作为前缀和数组: $p r e v [i] [j]$ 他表示从下标为 $（ 0, 0 ）$ 的元素累加到下标为 $(i, j)$ 元素的范围和（行坐标不超过 $i$ 列坐标不超过 $j$ ）
在这里插入图片描述
如上图所示， $p r e v [0] [0]$ 表示从（0，0）累加到（0，0）为0，prev[0][1]表示从（0，0）累加到（0，1）为1，prev[1][0]表示从（0，0）累加到（1，0）为0,prev[1][1]表示从（0，0）累加到（1，1）,为2.同理prev[1][2]表示从（0，0）累加到（1，2）为 $p r e v [1] [1] + p r e v [0] [2] - p r e v [0] [1] + a r r [1] [2]$

由此得到二位前缀和的递推公式为:
$p r e v [i] [j] = p r e v [i - 1] [j] + p r e v [i] [j - 1] - p r e v [i - 1] [j - 1] + a r r [i] [j]$
下面对其加以利用

/**
 * 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 prev[105][105];
int row,col;
int get_sum(int ** mat,int i,int j,int k){
    int rl=i-k<1?1:i-k;//行的左边界
    int rr=i+k>row?row:i+k;//行的有边界
    int cl=j-k<1?1:j-k;//列的左边界
    int cr=j+k>col?col:j+k;//列的有边界
    return prev[rr][cr]-prev[rl-1][cr]-prev[rr][cl-1]+prev[rl-1][cl-1];
    //要返回从（rl,cl)到（rr,lr）范围内的和
    //所以要先用（0，0）到（rr,lr）的前缀和减去prev[rl-1][cr],prev[rr][cl-1]
    //其中prev[rl-1][ll-1]被减去了两次要再加上一个，这是简单的容斥原理的运用
}
int** matrixBlockSum(int** mat, int matSize, int* matColSize, int k, int* returnSize, int** returnColumnSizes){
    memset(prev,0,sizeof(prev));
    row=matSize,col=matColSize[0];
    //求取前缀和
    for(int i=1;i<=row;i++){
        for(int j=1;j<=col;j++){
            prev[i][j]=prev[i-1][j]+prev[i][j-1]-prev[i-1][j-1]+mat[i-1][j-1];
            //为了防止越界行列坐标为1的时候越界下标从1开始
        }
    }
    row=matSize,col=matColSize[0];
    int **ans=(int**)malloc(sizeof(int*)*row);
    *returnColumnSizes=(int*)malloc(sizeof(int)*row);
    for(int i=0;i<row;i++){
        ans[i]=(int*)malloc(sizeof(int)*col);
        (*returnColumnSizes)[i]=matColSize[0];
    }
    for(int i=1;i<=row;i++){
        for(int j=1;j<=col;j++){
            ans[i-1][j-1]=get_sum(mat,i,j,k);
        }
    }
    *returnSize=matSize;
    return ans;
}

在这里插入图片描述

8.1030. 距离顺序排列矩阵单元格

原题链接

给定四个整数 rows, cols , rCenter 和 cCenter 。有一个 rows x cols 的矩阵，你在单元格上的坐标是 (rCenter, cCenter) 。
返回矩阵中的所有单元格的坐标，并按与 (rCenter, cCenter) 的距离从最小到最大的顺序排。你可以按任何满足此条件的顺序返回答案。
单元格(r1, c1) 和 (r2, c2) 之间的距离为|r1 - r2| + |c1 - c2|。
示例 1：
输入：rows = 1, cols = 2, rCenter = 0, cCenter = 0
输出：[[0,0],[0,1]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1]
示例 2：
输入：rows = 2, cols = 2, rCenter = 0, cCenter = 1
输出：[[0,1],[0,0],[1,1],[1,0]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2]
[[0,1],[1,1],[0,0],[1,0]] 也会被视作正确答案。
示例 3：
输入：rows = 2, cols = 3, rCenter = 1, cCenter = 2
输出：[[1,2],[0,2],[1,1],[0,1],[1,0],[0,0]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2,2,3]
其他满足题目要求的答案也会被视为正确，例如 [[1,2],[1,1],[0,2],[1,0],[0,1],[0,0]]。
提示：
1 <= rows, cols <= 100
0 <= rCenter < rows
0 <= cCenter < cols

这道题的做法也有很多，有排序，搜索等方法，但是搜索用C语言实现太繁琐了这里就偷懒介绍一下排序的方法了。使用排序的思路是先遍历矩阵中的每个点将其赋值为其坐标值，然后利用 $q s o r t ()$ 进行排序，代码实现较搜索而言简洁了不少。不过值得注意的是这里创建数组的方式和以往区别较大,因为题目要求我们返回的数组类似于C++中的 $v e c t o r < v e c t o r < i n t > >$ 即是返回数组中的每个元素也是一个数组,共有 $r o w s * c o l s$ 个元素，每个元素中又是一个有两个元素的数组,分别存储该元素在对应矩阵中的行和列。

/**
 * 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 x,y;
int cmp(const void * a,const void *b)//void *可以接受任何类型的指针
{
    int * pa=*(int**)a;//a传过来的是二级指针，先将其转换为二级指针再解引用拿到行列坐标
    int * pb=*(int**)b;
    return (abs(pa[0]-x)+abs(pa[1]-y))-(abs(pb[0]-x)+abs(pb[1]-y));
    //按照距离升序排列
}
int** allCellsDistOrder(int rows, int cols, int rCenter, int cCenter, int* returnSize, int** returnColumnSizes){
    int** ans=(int**)malloc(sizeof(int*)*rows*cols);
    //开辟rows*cols个元素
    *returnColumnSizes=(int*)malloc(sizeof(int)*rows*cols);
    for(int i=0;i<rows*cols;i++){
        ans[i]=(int*)malloc(sizeof(int)*2);
        //每个元素再指向一个两个元素的数组
        (*returnColumnSizes)[i]=2;
    }
    x=rCenter,y=cCenter;
    int cnt=0;
    for(int i=0;i<rows;i++){
        for(int j=0;j<cols;j++){
            ans[cnt][0]=i;
            ans[cnt][1]=j;
            cnt++;//为每个元素的行列赋值
        }
    }
    qsort(ans,rows*cols,sizeof(int *),cmp);//排序
    *returnSize=rows*cols;
    return ans;
}

在这里插入图片描述

三，今日收获

本日题目来自英雄那里归来的LeetCode零基础指南：《LeetCode零基础指南》(第八讲) 二级指针，感兴趣的可以自己尝试一下。今天多次对二维数组进行动态内存开辟操作，相信做完了这些题目之后动态开辟二维数组会没有任何难度。同时今天还用到了二维数组前缀和，搜索，将二维变一位等操作，都是不错的思想应该多多练习.