談一下稀疏數組

對於一個初窺數據結構的人來講，稀疏數組確實能夠很好的幫助你鍛鍊思惟。

但自從第三次科技革命後，人們都一直在作着用空間去換取時間的損事，而以時間換空間的稀疏數組，倒也跟北大考古專業有些心心相惜。

稀疏數組的基本介紹：

當一個數組中大部分元素爲0，或者爲同一個值時，能夠使用稀疏數組來保存該數組

如何建立一個稀疏數組：

• 記錄數組一共有幾行幾列，有多少不一樣的值
• 把具備不一樣值的元素的行列及值記錄在一個小規模數組中，從而縮小程序的規模

（小規模數組即是稀疏數組）

應用場景：

 

像在編寫的五子棋程序中，有存盤退出和續上局功能

在存盤的時候，將黑白子以及空位都分別以1,2,0存放在一個二維數組中，當棋盤上空位比較多的時候，大量的0（重複數據）會佔用較高的空間，爲了節省空間，便有了稀疏數組。

如上圖，將一個棋盤映射成爲一個二維數組，在數組中，有大量重複的數據.

這時，咱們能夠將棋盤的行、列以及非0的數據抽取出來，分別做爲稀疏數組的 SparseArray[0][0]、SparseArray[0][1]、SparseArray[0][2]。

將非重複數據的行、列、值依次存儲在稀疏數組中，便有了一個較小規模的數組，以節省空間。

二維數組轉稀疏數組思路：

• 遍歷原始的二維數組，獲得有效的數據個數sum；
• 根據個數建立稀疏數組sparseArr  int[sum + 1][3];
• 將二維數組的有效數據存入到稀疏數組。

稀疏數組轉原始的二維數組的思路：

• 先讀取稀疏數組的第一行，根據第一行建立原始數組chessArr2 = int[11]；
• 在讀取稀疏數組後幾行的數據，並賦給原始的二維數組。

package com.perwrj.sparsearray;

public class SparseArray {

    public static void main(String[] args) {
        /*
         * 原始數組的建立與遍歷
         */
        System.out.println("原始的二維數組");
        int  chessArr [][] = new int[11][11];
        chessArr [1][2] = 1;
        chessArr [2][3] = 2;
        for (int[] is : chessArr) {
            for (int is2 : is) {
                System.out.print("\t" + is2);
            }
            System.out.println("\n");
        }
        
        /*
         * 將原始數組轉換爲稀疏數組
         */
//        獲取原始數組中不爲零值的個數
        int sum = 0;
        for (int i = 0; i < chessArr.length; i++) {
            for (int j = 0; j < chessArr[i].length; j++) {
                if (chessArr[i][j] != 0) {
                    sum ++;
                }
            }
        }
//        給稀疏數組第一行賦值，分別爲原始數組的行，列，不爲零值個數
        int sparseArr[][] = new int [sum + 1][3];
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;
        
//        遍歷原始數組，爲稀疏數組其餘賦值（原始數組中非零的數）
        int count = 0;
        for (int i = 0; i < chessArr.length; i++) {
            for (int j = 0; j < chessArr[i].length; j++) {
                if (chessArr[i][j] != 0) {
                    count++;
                    sparseArr[count][0]= i;
                    sparseArr[count][1]= j;
                    sparseArr[count][2]= chessArr[i][j];
                }
            }
        }
        
//        打印遍歷稀疏數組
        System.out.println("稀疏數組");
        for (int[] is : sparseArr) {
            for (int is2 : is) {
                System.out.print("\t" + is2);
            }
            System.out.println("\n");
        }
        
        /*
         * 稀疏數組轉換爲原始數組
         */
//        用稀疏數組第一行建立原始數組
        int chessArr2 [][] = new int[sparseArr[0][0]][sparseArr[0][1]];
        
//        遍歷賦值原始數組
        for (int i = 1; i < sparseArr.length; i++) {
                chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
        
//        遍歷還原後的數組
        System.out.println("還原後的二維數組");
        for (int[] is : chessArr2) {
            for (int is2 : is) {
                System.out.print("\t" + is2);
            }
            System.out.println("\n");
        }
    }

}