Java 实现 二维数组 与 稀疏数组 之间的相互转换

效果图

思路分析

cust.aowei.sparseArray

SparseArray.java

• 创建原始二维数组11*11

• 0表示没有棋子，1表示黑子，2表示蓝子

• 输出原二维数组

• 将二维数组（chessArray）转为稀疏数组

• 先遍历二维数组 得到非0个数

• 创建对应的稀疏数组（sparseArray）

• 先给稀疏数组赋值

• 遍历二维数组，将非零的值存放到saprseArray

• count用于记录第几个非零数据

• 输出稀疏数组

• 稀疏数组恢复二维数组

• 先读取稀疏数组第一行，根据第一行数据，创建原始二维数组

• 读取稀疏数组后几行数据，并赋值给原来的二维数组

具体实现代码

package cust.aowei.sparseArray;

/**
 * @author aoxiaobao
 * @project DataStruct
 * @date 2019/10/2 - 18:19
 */
public class SparseArray {

    public static void main(String[] args) {

        Array array = new Array();

        // 创建二维数组
        int [][]cArray = array.createChessArray();
        array.loopChessArray(cArray);

        //将二维数组转为稀疏数组
        int [][]sArray = array.teansformSparseArray(cArray);
        array.loopSparseArray(sArray);

        //将稀疏数组转为二维数组
        int [][]cArray1 = array.teansformChessArray(sArray);
        array.loopChessArray(cArray1);
    }
}
class Array{
    private final int C=11;
    private final int  L=11;

    //创建原始二维数组11*11
    int[][]  createChessArray(){
        int [][]chessArray = new int[C][L];
        for(int i=0;i<C;i++){
            for (int j=0;j<L;j++){
                chessArray[i][j] = 0;
            }
        }
        //0表示没有棋子，1表示黑子，2表示蓝子
        chessArray[2][1]=1;
        chessArray[8][7]=2;
        chessArray[3][6]=2;
        return chessArray;
    }

    //输出原二维数组
    void loopChessArray(int[][] chessArray){
        System.out.println("原二维数组：");
        for(int i=0;i<C;i++){
            for (int j=0;j<L;j++){
                System.out.print(chessArray[i][j]+"    ");
            }
            System.out.println();
        }
    }

//        将二维数组（chessArray）转为稀疏数组
    int[][]  teansformSparseArray(int[][] chessArray){
//         count用于记录第几个非零数据
        int tempCount = 1;
//        先遍历二维数组 得到非0个数
        for(int i=0;i<C;i++){
            for (int j=0;j<L;j++){
                if(chessArray[i][j] != 0){
                    tempCount++;
                }
            }
        }

//        创建对应的稀疏数组（sparseArray）
        int [][]sparseArray = new int[tempCount][3];
        sparseArray[0][0]=C;
        sparseArray[0][1]=L;
        sparseArray[0][2]=tempCount;
        tempCount=1;
//        遍历二维数组，将非零的值存放到saprseArray
        for(int i=0;i<C;i++){
            for (int j=0;j<L;j++){
                if(chessArray[i][j] != 0){
                    sparseArray[tempCount][0]=i;
                    sparseArray[tempCount][1]=j;
                    sparseArray[tempCount][2]=chessArray[i][j];
                    tempCount++;
                }
            }
        }
        return sparseArray;
    }
    //输出稀疏数组
    void loopSparseArray(int[][] sparseArray){
        System.out.println("稀疏数组：");
        for(int i=0;i<sparseArray.length;i++){
            for (int j=0;j<sparseArray[0].length;j++){
                System.out.print(sparseArray[i][j]+"\t");
            }
            System.out.println();
        }
    }

//         稀疏数组恢复二维数组
    int[][]  teansformChessArray(int[][] sparseArray){
//         先读取稀疏数组第一行，根据第一行数据，创建原始二维数组
        int[][] chessArray = new int[sparseArray[0][0]][sparseArray[0][1]];

//         读取稀疏数组后几行数据，并赋值给原来的二维数组
        for(int i=1;i<sparseArray.length;i++){
            int j=0;
            chessArray[sparseArray[i][j]][sparseArray[i][j+1]] = sparseArray[i][j+2];
        }
        return chessArray;
    }
}

---