Leetcode---二维数组

二维数组

本博客的题均为leetcode上的摘录，都是我的刷题答案，仅做参考，若有错误，欢迎指正

二维数组简介

类似于一维数组，二维数组也是由元素的序列组成。但是这些元素可以排列在矩形网格中而不是直线上。

在内存空间中，数组的存储方式都是顺序存储结构，在一块内存地址中，数组的各个元素按顺序依次排序，存储在连续的地址中；二维数组也一样，只不过是每一行都按顺序存储，即先存储二维数组的第一行（每行还是按顺序依次存储在连续地址），在存储第二行，接着存储第三行。。。以此类推直至存储完所有的数据元素为止。

一、对角线遍历

给定一个含有 M x N 个元素的矩阵（M 行，N 列），请以对角线遍历的顺序返回这个矩阵中的所有元素，对角线遍历如下图所示。

示例:

输入:
[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]

输出:  [1,2,4,7,5,3,6,8,9]

解释:

说明:

1. 给定矩阵中的元素总数不会超过 100000 。

//C++实现
class Solution {
public:
    vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {
        if (matrix.empty())     //此处一定要判断是否为空
            return {};          //如果vector为空，返回空的vector就好了
         
        int m = matrix.size();      //获取二维数组的行和列数
        int n = matrix[0].size();
        
        vector<int> result(m*n);    //用来存放遍历的结果，size为m*n
        int r = 0;      //二维数组的两个索引
        int c = 0;
        for (int i = 0; i < result.size(); i++) {
            result[i] = matrix[r][c];
            
            if ((r + c) % 2 == 0) { //偶数情况
                
                //这三种情况是有顺序的，不能打乱
                if (c == n - 1) {     //元素在最后一列，往下走
                    r++;
                } else if (r == 0) {  //元素在第一行，往右走
                    c++;
                } else {              //其他情况，往右上走
                    r--;
                    c++;
                }
            } else {
                if (r == m - 1) {     //元素在最后一行，往右走
                    c++;
                } else if (c == 0) {  //元素在第一列，往下走
                    r++;
                } else {              //其他情况，往左下走
                    r++;
                    c--;
                }
            }
        }
        return result;            //返回对角线之后的vector

    }
};

二、螺旋矩阵

给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。

示例 1:

输入:
[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]
输出: [1,2,3,6,9,8,7,4,5]

示例 2:

输入:
[
  [1, 2, 3, 4],
  [5, 6, 7, 8],
  [9,10,11,12]
]
输出: [1,2,3,4,8,12,11,10,9,5,6,7]

//C++实现
class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> ret;
        if(matrix.empty())      //为空返回{}
            return {};
        
        while(!matrix.empty())        //matrix不为空就进入执行
        {
            //将matrix的第一行存到ret
            int size=matrix[0].size();
            for(int i=0;i<size;i++)
                ret.push_back(matrix[0][i]);
            
            //存储原matrix的行数列数
            int size_r=matrix.size();
            int size_c=matrix[0].size();

            //新建temp，比matrix少一行，列数相同，复制matrix除去第一行之后的所有元素到temp
            vector<vector<int>> temp(size_r-1,vector<int>(size_c,0));
            for(int i=1;i<matrix.size();i++)
            {
                for(int j=0;j<matrix[0].size();j++)
                    temp[i-1][j]=matrix[i][j];
            }
            
            /*将matrix减去第一行之后，旋转90°，再将第一行存到ret，以此类推*/
            //将matrix行数减一之后，行数和列数倒转
            matrix.resize(size_c);        //重置matrix的行数为原matrix的列数
            for(int i=0;i<matrix.size();i++)
                matrix[i].resize(size_r-1);    //逐行重置列数为原matrix的行数-1
            
            for(int i=0;i<matrix.size();i++)    //将temp的元素旋转90°之后，存到matrix
            {
                for(int j=0;j<matrix[i].size();j++)
                    matrix[i][j]=temp[j][matrix.size()-i-1];
            }
            
        }
        
        return ret;
    }
}

 

这道题的解题思路是：将matrix的第一行元素存到ret，然后再将matrix除去已经存到ret的第一行元素删去，然后将矩阵旋转90°，之后再将矩阵的第一行存到ret里面，直到matrix变为空矩阵为止。

三、杨辉三角

给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。

在杨辉三角中，每个数是它左上方和右上方的数的和。

示例:

输入: 5
输出:
[
     [1],
    [1,1],
   [1,2,1],
  [1,3,3,1],
 [1,4,6,4,1]
]

//C++实现
class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> ret(numRows);   //输入的数，即为杨辉三角的行数

        //杨辉三角每一行的列数即为行数的值，第一行为一列，第二行为两列。。。
        for(int i=0;i<ret.size();i++)       
        {
            ret[i].resize(i+1);
        }
        
        for(int i=0;i<ret.size();i++)
        {
            for(int j=0;j<i+1;j++)
            {
                if(j==0 || j==i)        //每行的第一个和最后一个元素为1
                    ret[i][j]=1;
                else                    //其他元素为上一行的同一列和前一列的元素和
                {
                    ret[i][j]=ret[i-1][j-1]+ret[i-1][j];
                }
            }
        }
        return ret;
    }
};

这一题比较简单