稀疏数组的实现

稀疏数组的实现

稀疏数组第一行输出的是
原始二维数组的 行 列 有效数值个数
其余输出的是：有效数值的行 有效数值的行 有效数值
思路：

• 二维数组转稀疏数组：
• 1.遍历原始的二位数组，得到有效数据的的个数sum
• 2.根据sum就可以创建稀疏数组，sparseArr int[sum+1][3]
• 3.将二维数组的有效数据传入稀疏数组

本例中的稀疏数组如下图：

public class DataStructures {
    public static void main(String[] args) {
        int arr[][]=new int[11][11];
        arr[1][2]=1;
        arr[2][3]=2;
        int sum=0;
        System.out.println("原始的二维数组");
        for (int[] row: arr) {
            for(int data:row){
                System.out.print(data+"\t");
        }System.out.println();
        }

//获取有效数值的个数
        for(int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                if(arr[i][j]>0){
                    sum+=1;
                }
            }
        }
        System.out.println("sum="+sum);

//创建一个稀疏数组
        int sparseArr[][]=new int[sum+1][3];
        sparseArr[0][0]=11;
        sparseArr[0][1]=11;
        sparseArr[0][2]=sum;

        int count=0;//用于记录第几个非0
        for(int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                if(arr[i][j]>0){
                    count++;
                    sparseArr[count][0]=i;
                    sparseArr[count][1]=j;
                    sparseArr[count][2]=arr[i][j];
                }
            }
        }

        //输出
        System.out.println();
        System.out.println("稀疏数组：");
        for(int i=0;i<sparseArr.length;i++){
            System.out.println("\t"+sparseArr[i][0]+"\t"+sparseArr[i][1]+"\t"+sparseArr[i][2]);
        }

执行结果如下：

• 稀疏数组转化为二维数组：
• 1.先读取稀疏数组第一行，创建原始的二维数组
• 2.在读取稀疏数组后几行的数据，并赋给原始的二维数组

package 稀疏数组的实现01.稀疏数组转化成二维数组;

/**
 * 二维数组转化为稀疏数组：
 * 1.先读取稀疏数组第一行，创建原始的二维数组
 * 2.在读取稀疏数组后几行的数据，并赋给原始的二维数组
 *
 * */
public class DataStructures2 {
    public static void main(String[] args) {
        //创建一个稀疏数组
        int sparseArr[][]=new int[4][3];
        sparseArr[0][0]=11;
        sparseArr[0][1]=11;
        sparseArr[0][2]=2;

        sparseArr[1][0]=1;
        sparseArr[1][1]=2;
        sparseArr[1][2]=1;

        sparseArr[2][0]=2;
        sparseArr[2][1]=3;
        sparseArr[2][2]=2;

        sparseArr[3][0]=1;
        sparseArr[3][1]=4;
        sparseArr[3][2]=2;

        System.out.println("初始稀疏数组为：");
        for(int i=0;i<sparseArr.length;i++){
            for(int j=0;j<sparseArr[i].length;j++){
                System.out.print(sparseArr[i][j]+"\t");
            }
            System.out.println();
        }

        int arr[][]=new int[sparseArr[0][0]][sparseArr[0][1]];
        for(int i=1;i<sparseArr.length;i++){
            arr[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
        }

//        int count=0;
//        for(int i=0;i<arr.length;i++){
//            count++;
//            for (int j=0;j<arr[i].length;j++){
//                if(count<sparseArr.length){
//                if(sparseArr[count][2]==1){
//                    arr[sparseArr[count][0]][sparseArr[count][1]]=1;
//                }
//                if(sparseArr[count][2]==2){
//                    arr[sparseArr[count][0]][sparseArr[count][1]]=2;
//                }
//          }}
//        }

        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }

    }
}

执行结果为：