稀疏數組SparseArray

一、基本內容

當一個二維數組中大部分的元素爲0或者爲同一個值時，可以使用稀疏數組保存該數組，從而縮小程序的規模。

稀疏數組只有三列，如下：

其中：

n:原二維數組有效數據的個數

row：原二維數組的總行數

clo：原二維數組的總列數

val：原二維數組中有效數據的個數

row1：原二維數組中第一個有效數的行數

clo1：原二維數組中第一個有效數的列數

val1：原二維數組中第一個有效數據的值

...

rown：原二維數組中第n個有效數的行數

clon：原二維數組中第n個有效數的列數

valn：原二維數組中第n個有效數據的值

 

二、二維數據與稀疏數組的相互轉換

1. 二維數組轉稀疏數組

   1. 遍歷二維數組，得到有效數據的個數sum
   2. 創建稀疏數組，int[sum+1][3]
   3. 將二維數組的有效數據存入稀疏數組
2. 稀疏數組轉二維數組
   1. 讀取稀疏數組的第一行，根據第一行數據創建二維數組
   2. 根據稀疏數組的後幾行給二維數組賦值

二、應用場景：五子棋程序

三、例子

public static void main(String[] args) {

        /**
         * 二維數組：11*11
         * 0：無棋子
         * 1：白子
         * 2：黑子
         */

        //二維數組
        int chessArr[][] = new int[11][11];
        chessArr[1][2] = 1;//白子
        chessArr[2][3] = 2;//黑子
        chessArr[3][3] = 1;//白子

        //輸出原始二維數組
        System.out.println("原始二維數組");
        for (int[] row: chessArr) {
            for (int item:row){
                System.out.printf("%d\t",item);
            }
            System.out.println();
        }

        //轉稀疏數組
        //原二維數組的行數與列數
        int rows = chessArr.length;
        int cols = chessArr[0].length;

        //1.獲得二維數組中有效數據的個數

        int sum = 0;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (chessArr[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("二維數組有效數據的個數："+sum);

        //創建稀疏數組
        int sparseArr[][] = new int[sum+1][3];
        //將二維數組的有效數據存入稀疏數組
        sparseArr[0] = new int[]{rows,cols,sum};

        //遍歷原二維數組，將有效數據存入稀疏數組
        int row = 0;
        for (int i = 0;i<rows;i++){
            for (int j = 0;j<cols;j++){
                if(chessArr[i][j] != 0){
                    row++;
                    sparseArr[row][0]=i;
                    sparseArr[row][1]=j;
                    sparseArr[row][2]=chessArr[i][j];
                }
            }

        }
        //輸出稀疏數組
        System.out.println("稀疏數組：");
        for (int i = 0;i<sum+1;i++) {
            System.out.printf("%d\t%d\t%d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
        }


        //稀疏數組轉換爲二維數組
        System.out.println("稀疏數組轉換爲二維數組,轉化後的二維數組：");
        int[][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]];

        //遍歷稀疏數組，根據稀疏數組中的數據給二維數組賦值
        int sparseArr_rows = sparseArr.length;
        for (int i = 1;i<sparseArr_rows;i++){

            chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }

        //打印二維數組
        for (int[] ints:chessArr2) {
            for (int item:ints){
                System.out.printf("%d\t",item);
            }
            System.out.println();
        }


    }