Java 二维数组与稀疏数组互转

基本介绍

二维数组

二维数组本质上是以数组作为数组元素的数组，即“数组的数组”，类型说明符 数组名[常量表达式][常量表达式]。二维数组又称为矩阵，行列数相等的矩阵称为方阵。对称矩阵a[i][j] = a[j][i]，对角矩阵：n阶方阵主对角线外都是零元素。

稀疏数组

稀疏数组我的理解是：是通过只存储和处理非零元素从而大幅度降低存储空间需求以及计算复杂度，多行三列的形式。

互转的思路

二维数组 转 稀疏数组

1. 遍历原始的二维数组，得到二维数组的有效数值的个数sun。
2. 根据sun创建出稀疏数组 parseArray int[sum=1][3]。
3. 将有效的二维数组的有效值存入稀疏数组。

稀疏数组 转 二维数组

1. 先读取稀疏数组的第一行，通过第一行的数据创建出二维数组。
2. 在读取稀疏数组后几行的数据，依次赋值即可

代码实现

1. 创建一个二维数组

/**
     *@描述   创建二维数组
     *@创建人  _╃君戰ヽ天
     *@创建时间  2019/10/24
     */
    public static int[][] getChessArr(){
        //创建一个二维数组
        int chessArr[][] = new int[11][11];
        //给数组赋值
        chessArr[1][1] = 1;
        chessArr[2][2] = 2;
        chessArr[3][3] = 1;
        chessArr[4][4] = 2;
        chessArr[5][5] = 1;
        chessArr[6][6] = 2;
        chessArr[7][7] = 1;
        chessArr[8][8] = 2;
        chessArr[9][9] = 1;
        chessArr[10][10] = 2;
        //输出打印
        System.out.println("二维数组:");
        for (int[] row :  chessArr){
            for(int data : row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        return chessArr;
    }

    public static void main(String[] args) {
        int[][] chessArr = getChessArr();
    }

2. 获取二维数组的非0的个数

    /**
     *@描述   获取二维数组的非0的个数
     *@创建人  _╃君戰ヽ天
     *@创建时间  2019/10/24
     */
    public static int getSum(int[][] chessArr){
        int sum = 0;
        for (int[] row :  chessArr){
            for(int data : row){
                if(data != 0){
                    sum++;
                }
            }
        }
        return sum;
    }

3. 二维数组转稀疏数组

/**
     *@描述   二维数组转稀疏数组
     *@创建人  _╃君戰ヽ天
     *@创建时间  2019/10/24
     */
    public static int[][] getParseArray(int[][] chessArr) {
        int sum = getSum(chessArr);                 //原始二维数组非0的个数
        int[][] parseArray = new int[sum+1][3];     //创建稀疏数组
        parseArray[0][0] = 11;
        parseArray[0][1] = 11;
        parseArray[0][2] = sum;
        int count = 0;
        for(int i =0;i < 11;i++){
            for(int j = 0;j < 11;j++){
                if(chessArr[i][j] != 0){
                    count++;
                    parseArray[count][0] = i;
                    parseArray[count][1] = j;
                    parseArray[count][2] = chessArr[i][j];
                }
            }
        }
        return parseArray;
    }
        public static void main(String[] args) {
        int[][] chessArr = getChessArr();               //原始二维数组
        int[][] parseArray = getParseArray(chessArr);   //转后的稀疏数组
        System.out.println("转后的稀疏数组:");
        for (int i = 0 ; i < parseArray.length; i++){
            System.out.printf("%d\t%d\t%d\t\n",parseArray[i][0],parseArray[i][1],parseArray[i][2]);
        }
    }

4. 稀疏数组恢复二维数组

/**
     *@描述   稀疏数组恢复二维数组
     *@创建人  _╃君戰ヽ天
     *@创建时间  2019/10/24
     */
    public static int[][] getChessArr(int[][] parseArray) {
        int row = parseArray[0][0];
        int col = parseArray[0][0];
        int chessArr[][] = new int[row][col];
        for (int i = 0 ; i < parseArray.length; i++){
            if(i !=0){
                chessArr[parseArray[i][0]][parseArray[i][1]] = parseArray[i][2];
            }
        }
        //输出打印
        System.out.println("恢复后的二维数组:");
        for (int[] rows :  chessArr){
            for(int data : rows){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        return chessArr;
    }
   
    public static void main(String[] args) {
        int[][] chessArr = getChessArr();               //原始二维数组
        int[][] parseArray = getParseArray(chessArr);   //转后的稀疏数组
        System.out.println("转后的稀疏数组:");
        for (int i = 0 ; i < parseArray.length; i++){
            System.out.printf("%d\t%d\t%d\t\n",parseArray[i][0],parseArray[i][1],parseArray[i][2]);
        }
        getChessArr(parseArray);
    }