二维数组与稀疏数组的转换

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

一、稀疏数组是什么

当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来存该数组。
稀疏数组

稀疏数组的第一行表示原二维数组有多少行、多少列、有效值
从第二行开始记录每个有效值的所在行和列

二、稀疏数组的处理方法

（1）记录数组一共有几行几列，有多少个不同的值
（2）把具有不同值的元素的行列以及值记录在一个小规模的数组中，从而缩小数组规模。

三、思路分析

1）二维数组转稀疏数组

1.遍历二维数组，得到有效数据个数(sum)。
2.根据sum创建稀疏数组sparseArr int[sum+1][3] ->3代表row col value。
3.将二维数组的有效数据存入稀疏数组。

2）稀疏数组转二维数组

1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组。
2.在读取稀疏数组的后几行的数据，并赋值给新的二维数组。

四、代码实现（java）

package com.hntou.sparsearray;

import java.util.Scanner;

public class mineTest {
    public static void main(String[] args) {
        //1.生成一个二维数组
        int[][] arr1 = createArr();
        System.out.println("初始二维数组为:");
        printArr(arr1);
        //2.把二维数组转换为稀疏数组
        int[][] sparseArr = toSparseArr(arr1);
        System.out.println("稀疏数组为:");
        printArr(sparseArr);
        //3.把稀疏数组恢复为二维数组
        int[][] arr2 = sparsetoArr(sparseArr);
        System.out.println("恢复后的二维数组为:");
        printArr(arr2);
    }

    //创建二维数组(行、列、赋值次数)
    public static int[][] createArr() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入二维数组行大小:");
        int rowLength = sc.nextInt();
        System.out.println("请输入二维数组列大小:");
        int colLength = sc.nextInt();
        System.out.println("请输入需要赋值的次数:");
        int n = sc.nextInt();
        int[][] arr1 = new int[rowLength][colLength];
        for (int i = 0; i < n; i++) {
            System.out.println("请输入您要赋值的行号:");
            int j = sc.nextInt();
            System.out.println("请输入您要赋值的列号:");
            int k = sc.nextInt();
            System.out.println("请输入您要赋值的具体值:");
            int m = sc.nextInt();
            System.out.println("您给二维数组的第" + (j + 1) + "行," + "第" + (k + 1) + "列的赋值为:" + m);
            //保存值
            arr1[j][k] = m;
        }
        return arr1;
    }

    //二维数组转换为稀疏数组
    public static int[][] toSparseArr(int[][] arr) {
        //初始化稀疏数组
        int sum = torealValue(arr);
        // 稀疏数组3列固定 row col value 第一行存储原数组行列大小和有效值个数,第二行开始存储有效值和其所在行、列号
        int[][] sparseArr = new int[sum + 1][3];
        // 为稀疏数组第一行赋值
        sparseArr[0][0] = arr.length; //二维数组有多少行 row
        sparseArr[0][1] = arr.length; //二维数组有多少列 col
        sparseArr[0][2] = sum; //有效值个数
        // 为稀疏数组第二行以后的开始赋值
        int count = 0; //行号计数
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                if (arr[i][j] != 0) {
                    count++;//从第二行开始
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = arr[i][j];
                }
            }
        }
        return sparseArr;
    }

    //统计二维数组内的有效值
    public static int torealValue(int[][] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                if (arr[i][j] != 0) {
                    sum++;
                }
            }
        }
        return sum;
    }

    //稀疏数组转换为二维数组
    public static int[][] sparsetoArr(int[][] sparseArr){
        //创建新的二维数组
        //新二维数组的行为:稀疏数组的第一行第一列 新二维数组的列为:稀疏数组的第一行第二列
        int[][] arr2 = new int[sparseArr[0][0]][sparseArr[0][1]];
        //为新二维数组赋值,需要赋值的次数为有效值的个数
        for (int i = 1; i <= sparseArr[0][2]; i++) {
            //稀疏数组第二行第一列开始->对应新数组的行  稀疏数组第二行第二列开始->对应新数组的列
            //稀疏数组的第二行第三列开始->对应新数组的值
            arr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
        return arr2;
    }

    //打印二维数组
    public static void printArr(int[][] arr) {
        //遍历行->一维数组
        for (int[] row : arr) {
            //遍历列 -> 遍历每一行的值存入data中
            for (int data : row) {
                System.out.print(data + " ");
            }
            System.out.println();
        }
    }
}

---

五、效果图

总结

封装时出现的几个问题

1.封装打印二维数组方法的时候只能实现n行n列的二维数组。
2.如果行数大于列数(eg:5行4列) 最终效果会多一列
3.如果行数小于列数(eg:4行5列) 最终效果会少一列
因为打印时候的for循环外层循环的是二维数组的行也就是一个一维数组，如果行大于列，自然在从稀疏数组转换为二维数组的时候会多一列0,因为会多循环一次，如果行小于列自然会少一列显示不了。所以只支持n行n列的二维数组。

稀疏数组应用实例

1.使用稀疏数组来保存前面的二维数组（棋盘、地图等等）
2.把稀疏数组存盘，并且可以重新恢复为原来的二维数组（用于类似于悔棋功能）