數據結構篇——數組擴展（稀疏數組）

其實稀疏數組更多的是一種思想，而不是一種全新獨立的數據結構。它本質上也就是一個二維數組。

稀疏數組簡介以及應用場景

當一個數組容量很大，但是其中有效數據很少且是稀疏分佈時，我們就可以使用稀疏數組來減少不必要的內存消耗。
注：這裏的有效數據，也可以理解爲與絕大部分數據不同的。加上這個理解後，稀疏數組的應用場景會多很多。

其實思想很簡單，構建出來一個二維數組，然後把有效數據的座標都一一標記出來放進二維數組中。

稀疏數組的結構

稀疏數組本質上也是一個數組。
稀疏數組由（N+1）x3構成。
第一行的三個值依次表示

原數組的行號	原數組的列號	有幾個格子有數據

之後的每一行都表示一個特定的值。

有意義值的行號	有意義值的列號	有意義的值

所以我們可以得到假設一個數組有效值數量爲N，則他的行數爲N+1。
通過稀疏數組的結構，我們又能得到一個信息。稀疏數組比較適合用來處理規整數組（即矩陣），如果不是矩陣但同時又滿足稀疏數組應用場景的，可以通過數組補齊的方式，把原數組變成矩陣。

稀疏數組實現

public class SparseArray {

    /**
     * 把普通二維規整數組變成稀疏數組
     *
     * @param array        二維規整數組
     * @param defaultValue 二維數組中默認的值（大部分座標的值）
     * @return 稀疏數組
     */
    public static int[][] toSparseArray(int[][] array, int defaultValue) {
        if (array.length == 0) {
            return new int[0][0];
        }

        //首次遍歷數組 創建稀疏數組
        int sum = 0;
        int line = array.length;
        int column = array[0].length;
        for (int i = 0; i < line; i++) {
            for (int j = 0; j < column; j++) {
                if (array[i][j] != defaultValue) {
                    sum++;
                }
            }
        }

        int[][] sparseArray = new int[sum + 1][3];
        sparseArray[0][0] = line;
        sparseArray[0][1] = column;

        //第二次遍歷數組 給稀疏數組塞值
        int lineNo = 1;
        for (int i = 0; i < line; i++) {
            for (int j = 0; j < column; j++) {
                if (array[i][j] != defaultValue) {
                    sum++;
                    sparseArray[lineNo][0] = i;
                    sparseArray[lineNo][1] = j;
                    sparseArray[lineNo][2] = array[i][j];
                    lineNo++;
                }
            }
        }
        sparseArray[0][2] = sum;
        return sparseArray;
    }

    /**
     * 把稀疏數組變成二維規整數組
     *
     * @param sparseArray  稀疏數組
     * @param defaultValue 二維數組中默認的值（大部分座標的值）
     * @return 二維規整數組
     */
    public static int[][] toArray(int[][] sparseArray, int defaultValue) {
        int line = sparseArray[0][0];
        int column = sparseArray[0][1];
        int[][] array = new int[line][column];
        for (int i = 0; i < line; i++) {
            for (int j = 0; j < column; j++) {
                array[i][j] = defaultValue;
            }
        }

        int size = sparseArray.length;
        for (int i = 1; i < size; i++) {
            array[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        return array;
    }

    public static void main(String[] args) {
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        array[4][5] = 2;
        System.out.println("原始的二維數組~~");
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                System.out.print(array[i][j]+"  ");
            }
            System.out.println();
        }
        int[][] sparseArray = SparseArray.toSparseArray(array, 0);

        System.out.println("稀疏數組~~");
        for (int i = 0; i < sparseArray.length; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(sparseArray[i][j]+"  ");
            }
            System.out.println();
        }
    }
}

總結

正如本篇文章一開始介紹的，稀疏數組更偏向于思想，本身沒有什麼難度。相信大家應該很容易理解~下篇博文再見啦！