我的Java数据结构学习-2---稀疏数组

数据结构：线性结构   非线性结构。

线性结构：顺序存储结构    /        链式存储结构

 

 

 

 

第一个案例：稀疏数组

 

 

 

 

 

 

 

 

 

 稀疏数组案例：

 

稀疏数组：思路：

 

 代码实现：

 

 

package Demo1.SparseArray;

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

        SparseArr sparseArr = new SparseArr();

        //（0，表示没有棋子，1表示黑子，2表示白子）
        //1.创建原始的二位数组（棋盘）
        int[][] chessAray1 = new int[11][11];
        chessAray1[1][2]=1;
        chessAray1[2][3]=2;
        chessAray1[2][2]=2;
        chessAray1[5][3]=1;
        //查看原始数组
        System.out.println("原始二维数组:");
        sparseArr.PrintfForByArray(chessAray1);
        //转换稀疏数组：
        System.out.println("优化二维数组:----》稀疏数组：");
        int[][] sparse = sparseArr.Sparce(chessAray1);
        sparseArr.PrintfForByArray(sparse);

        //稀疏数组转换回原始二维数组
        System.out.println("稀疏数组----->原始数组：");
        int[][] chessArray = sparseArr.chessArray(sparse);
        sparseArr.PrintfForByArray(chessArray);



    }
    //封装将二维数组转换为稀疏数组方法：稀疏数组 int【sum+1】【3】
    public int[][] Sparce(int[][] array){

        //1.遍历二维数组，得到非零数据的个数
        int sum =0;
        for (int i = 0; i < array.length; i++) {

            for (int j = 0; j < array[0].length; j++) {
                if (array[i][j]!=0){
                    sum++;
                }
            }
        }
        //2.创建对应的稀疏数组
        int[][] SparseArray =  new  int[sum+1][3];
        //给稀疏数组复制
        SparseArray[0][0]=array.length;//存二维数组的行值
        SparseArray[0][1]=array[0].length;//存二维数组的列值
        SparseArray[0][2]=sum;

        //遍历二维数组，将非零的值存放到稀疏数组中
        //定一个计数，给新的数组顺序。
        int count =0;

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[0].length; j++) {
                if (array[i][j]!=0){
                    count++;
                    SparseArray[count][0]=i;
                    SparseArray[count][1]=j;
                    SparseArray[count][2]=array[i][j];
                }
            }
        }
        //查看稀疏数组
       // System.out.println("稀疏数组：");
      // PrintfForByArray(SparseArray);


        return SparseArray;
    }

    //封装循环遍历二维数组打印方法：
    public void PrintfForByArray(int[][] SparseArray){
        for (int[] item : SparseArray) {
            for (int data : item) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
    }
    //封装将稀疏数组恢复为原始数组方法：
    public int[][] chessArray(int[][] SparseArray){
        //还原稀疏数组保存的原始数组的行列
        int row = SparseArray[0][0];
        int low = SparseArray[0][1];
        //建立原始数组
        int[][]  chessArray = new int[row][low];
        //恢复原二维数组的值,有效数组是第二行开始
        for (int i = 1; i < SparseArray.length; i++) {
            //获取稀疏数组的行与列
            int rowTemp = SparseArray[i][0];
            int lowTemp = SparseArray[i][1];
            int result = SparseArray[i][2];
            chessArray[rowTemp][lowTemp]=result;
        }
        return chessArray;
    }




}