01-java数据结构之稀疏数组的学习

1、稀疏Sparsearry数组

1.1 先看一个实际需求引出稀疏数组

此处引用韩老师的五子棋程序

问题：该二维数组的很多默认值是0，因此记录了**很多没有意义的数据--->稀疏数组**

1.2、稀疏数组的定义

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

稀疏数组的处理方式：

• 记录数组有几行几列，有多少个不同值
• 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
  
  大概意思就是，原始二维数组假设是n行n列，有num个非0值，那么稀疏数组应该为num行3列
  稀疏数组的第一行存储原始二维数组的**行 列 有效值个数**，其后的每一行存储的是每一个有效值在原始二维数组中所对应的行 列 值。

2、稀疏数组的实操

就以上面的棋盘为例：创建一个11行11列的二维数组，给它三个有效值。

2.1、创建原始数组

public class sparsearrayTest {
    public static void main(String[] args) {

        // 创建一个原始二维数组6*6
        // 0:表示没有棋子，1表示黑子  2表示白字
        int chessArr1[][]=new int[11][11];
        chessArr1[1][2]=1;
        chessArr1[2][3]=2;
        chessArr1[4][6]=6;
        // 输出原始的二维数组
        System.out.println("原始的二维数组~~~");
        for(int[] arr:chessArr1){
            for(int item:arr){
                System.out.printf("%d\t", item);
            }
            System.out.println();
        }

运行结果：

2.2、转变为稀疏数组

• 1、获取原始二维数组的有效值个数

        // 有效数据个数
        int sum=0;
        for(int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                if(chessArr1[i][j]!=0){
                    sum++;
                }
            }
        }

• 2、创建稀疏数组，并将有效值赋值给稀疏数组

        // 将二维数组变成稀疏数组
        int sparseArr[][]=new int[sum+1][3];
        sparseArr[0][0]=11;
        sparseArr[0][1]=11;
        sparseArr[0][2]=sum;

        // 每次有一个有效值，当前行三个数就是有效值的行 列  值
        // 第一个非0值放第一行，第二个放第二行
        int k=0;
        // 二维数组的有效值进行赋值给稀疏数组
        for(int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                if(chessArr1[i][j]!=0){
                    k++;
                    sparseArr[k][0]=i;
                    sparseArr[k][1]=j;
                    sparseArr[k][2]=chessArr1[i][j];
                }
            }
        }

• 3、输出稀疏数组

        // 输出稀疏数组
        System.out.println("稀疏数组~~~");
        for (int arr[]:sparseArr) {
            for(int item:arr){
                System.out.printf("%d\t",item);
            }
            System.out.println();
        }

运行结果：

2.3、将稀疏数组转变为原始二维数组

• 1、创建新的二维数组，并开始转变

sparseArr[0][0]表示的就是原始数组的行
sparseArr[0][0]表示的就是原始数组的列

        // 将稀疏数组恢复成原始的数组
        int chessArr2[][]=new int[sparseArr[0][0]][sparseArr[0][1]];
        for(int i=1;i<sparseArr.length;i++){
            // sparseArr[i][0]表示的是第i个非0值的第一个下标
            chessArr2[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
        }

• 2、输出新的二维数组

        System.out.println("输出恢复的原始数组~~~");
        for (int arr[]:chessArr2) {
            for(int item:arr){
                System.out.printf("%d\t",item);
            }
            System.out.println();
        }

运行结果：

2.4、代码

/**
 * @User: 老潘
 * @date 2022年10月10日20:07
 * 稀疏数组
 */
public class sparsearrayTest {
    public static void main(String[] args) {

        // 创建一个原始二维数组6*6
        // 0:表示没有棋子，1表示黑子  2表示白字
        int chessArr1[][]=new int[11][11];
        chessArr1[1][2]=1;
        chessArr1[2][3]=2;
        chessArr1[4][6]=6;
        // 输出原始的二维数组
        System.out.println("原始的二维数组~~~");
        for(int[] arr:chessArr1){
            for(int item:arr){
                System.out.printf("%d\t", item);
            }
            System.out.println();
        }

        // 有效数据个数
        int sum=0;
        for(int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                if(chessArr1[i][j]!=0){
                    sum++;
                }
            }
        }
        // 将二维数组变成稀疏数组
        int sparseArr[][]=new int[sum+1][3];
        sparseArr[0][0]=11;
        sparseArr[0][1]=11;
        sparseArr[0][2]=sum;

        // 每次有一个有效值，当前行三个数就是有效值的行 列  值
        // 第一个非0值放第一行，第二个放第二行
        int k=0;
        // 二维数组的有效值进行赋值给稀疏数组
        for(int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                if(chessArr1[i][j]!=0){
                    k++;
                    sparseArr[k][0]=i;
                    sparseArr[k][1]=j;
                    sparseArr[k][2]=chessArr1[i][j];
                }
            }
        }
        // 输出稀疏数组
        System.out.println("稀疏数组~~~");
        for (int arr[]:sparseArr) {
            for(int item:arr){
                System.out.printf("%d\t",item);
            }
            System.out.println();
        }

        // 将稀疏数组恢复成原始的数组
        int chessArr2[][]=new int[sparseArr[0][0]][sparseArr[0][1]];
        for(int i=1;i<sparseArr.length;i++){
            // sparseArr[i][0]表示的是第i个非0值的第一个下标
            chessArr2[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
        }
        System.out.println("输出恢复的原始数组~~~");
        for (int arr[]:chessArr2) {
            for(int item:arr){
                System.out.printf("%d\t",item);
            }
            System.out.println();
        }
   }
}