'稀疏數組的應用與實踐，別再說學不好數據結構了'

數據結構五子棋黑子 Java 算法 Java聖鬥士 2019-08-11

Hello 各位熱愛學習的小夥伴們大家好，今天來給大家聊聊五子棋遊戲的後臺實現。

相信大家都玩過五子棋遊戲，規則就是率先連成 5 顆棋子的一方獲勝。小編小的時候也非常喜歡玩五子棋，覺得自己天下無敵了，對手再怎麼努力都不會逃脫自己的圍追堵截，堵著堵著就贏了，哈哈。

Hello 各位熱愛學習的小夥伴們大家好，今天來給大家聊聊五子棋遊戲的後臺實現。

可是你有想過五子棋的“保存棋局”和“續上局”是如何實現的嗎？

五子棋的數據結構描述

我們知道，五子棋有一個正方形棋盤，分別設有白子和黑子：

Hello 各位熱愛學習的小夥伴們大家好，今天來給大家聊聊五子棋遊戲的後臺實現。

可是你有想過五子棋的“保存棋局”和“續上局”是如何實現的嗎？

五子棋的數據結構描述

我們知道，五子棋有一個正方形棋盤，分別設有白子和黑子：

那麼這個五子棋盤就可以使用二維數組來描述，假設是一個 11 × 11 的二維數組：

int[][] chessArr = new int[11][11];

然後我們輸出一下：

for (int[] row : chessArr) {
\tfor (int data : row) {
\t\tSystem.out.printf("%d ", data);
\t}
\tSystem.out.println();
}

Hello 各位熱愛學習的小夥伴們大家好，今天來給大家聊聊五子棋遊戲的後臺實現。

可是你有想過五子棋的“保存棋局”和“續上局”是如何實現的嗎？

五子棋的數據結構描述

我們知道，五子棋有一個正方形棋盤，分別設有白子和黑子：

那麼這個五子棋盤就可以使用二維數組來描述，假設是一個 11 × 11 的二維數組：

int[][] chessArr = new int[11][11];

然後我們輸出一下：

for (int[] row : chessArr) {
\tfor (int data : row) {
\t\tSystem.out.printf("%d ", data);
\t}
\tSystem.out.println();
}

然後我們先來填幾顆棋子，模擬一個五子棋局，在代碼中，由於初始的二維數組中默認都是 0 ，那我們就可以考慮用 1 代表黑子，用 2 代表白子：

chessArr[1][2] = 1; // 黑子先行
chessArr[2][3] = 2; // 白子緊隨其後
chessArr[1][4] = 1; // 黑子欲形成橫向三連之勢
chessArr[1][3] = 2; // 白子“挺進大別山”斷了黑子的陰謀

再輸出，就可以看到黑子白子形成的“圍追堵截”之勢了，有沒有點懷念小時候的感覺？

Hello 各位熱愛學習的小夥伴們大家好，今天來給大家聊聊五子棋遊戲的後臺實現。

可是你有想過五子棋的“保存棋局”和“續上局”是如何實現的嗎？

五子棋的數據結構描述

我們知道，五子棋有一個正方形棋盤，分別設有白子和黑子：

那麼這個五子棋盤就可以使用二維數組來描述，假設是一個 11 × 11 的二維數組：

int[][] chessArr = new int[11][11];

然後我們輸出一下：

for (int[] row : chessArr) {
\tfor (int data : row) {
\t\tSystem.out.printf("%d ", data);
\t}
\tSystem.out.println();
}

然後我們先來填幾顆棋子，模擬一個五子棋局，在代碼中，由於初始的二維數組中默認都是 0 ，那我們就可以考慮用 1 代表黑子，用 2 代表白子：

chessArr[1][2] = 1; // 黑子先行
chessArr[2][3] = 2; // 白子緊隨其後
chessArr[1][4] = 1; // 黑子欲形成橫向三連之勢
chessArr[1][3] = 2; // 白子“挺進大別山”斷了黑子的陰謀

再輸出，就可以看到黑子白子形成的“圍追堵截”之勢了，有沒有點懷念小時候的感覺？

棋盤的壓縮保存

接下來就是今天的正題！如果你已經看到這裡，一定要堅持！

五子棋的保存實際上並不是保存整個棋盤，而是通過一個叫做“稀疏數組”的結構來完成的。

稀疏數組，顧名思義是一個很稀疏的數組......

Hello 各位熱愛學習的小夥伴們大家好，今天來給大家聊聊五子棋遊戲的後臺實現。

可是你有想過五子棋的“保存棋局”和“續上局”是如何實現的嗎？

五子棋的數據結構描述

我們知道，五子棋有一個正方形棋盤，分別設有白子和黑子：

那麼這個五子棋盤就可以使用二維數組來描述，假設是一個 11 × 11 的二維數組：

int[][] chessArr = new int[11][11];

然後我們輸出一下：

for (int[] row : chessArr) {
\tfor (int data : row) {
\t\tSystem.out.printf("%d ", data);
\t}
\tSystem.out.println();
}

然後我們先來填幾顆棋子，模擬一個五子棋局，在代碼中，由於初始的二維數組中默認都是 0 ，那我們就可以考慮用 1 代表黑子，用 2 代表白子：

chessArr[1][2] = 1; // 黑子先行
chessArr[2][3] = 2; // 白子緊隨其後
chessArr[1][4] = 1; // 黑子欲形成橫向三連之勢
chessArr[1][3] = 2; // 白子“挺進大別山”斷了黑子的陰謀

再輸出，就可以看到黑子白子形成的“圍追堵截”之勢了，有沒有點懷念小時候的感覺？

棋盤的壓縮保存

接下來就是今天的正題！如果你已經看到這裡，一定要堅持！

五子棋的保存實際上並不是保存整個棋盤，而是通過一個叫做“稀疏數組”的結構來完成的。

稀疏數組，顧名思義是一個很稀疏的數組......

咳咳，稀疏數組實際上是一個只保存原始二維數組有效數據，去掉無效數據的一個二維數組。

當一個數組中大部分元素是0，或為同一個值的時候，可以使用稀疏數組來保存數組。它是一個十分有效的壓縮存儲結構，而且還不涉及任何複雜的算法，簡單又實用！！

Hello 各位熱愛學習的小夥伴們大家好，今天來給大家聊聊五子棋遊戲的後臺實現。

可是你有想過五子棋的“保存棋局”和“續上局”是如何實現的嗎？

五子棋的數據結構描述

我們知道，五子棋有一個正方形棋盤，分別設有白子和黑子：

那麼這個五子棋盤就可以使用二維數組來描述，假設是一個 11 × 11 的二維數組：

int[][] chessArr = new int[11][11];

然後我們輸出一下：

for (int[] row : chessArr) {
\tfor (int data : row) {
\t\tSystem.out.printf("%d ", data);
\t}
\tSystem.out.println();
}

然後我們先來填幾顆棋子，模擬一個五子棋局，在代碼中，由於初始的二維數組中默認都是 0 ，那我們就可以考慮用 1 代表黑子，用 2 代表白子：

chessArr[1][2] = 1; // 黑子先行
chessArr[2][3] = 2; // 白子緊隨其後
chessArr[1][4] = 1; // 黑子欲形成橫向三連之勢
chessArr[1][3] = 2; // 白子“挺進大別山”斷了黑子的陰謀

再輸出，就可以看到黑子白子形成的“圍追堵截”之勢了，有沒有點懷念小時候的感覺？

棋盤的壓縮保存

接下來就是今天的正題！如果你已經看到這裡，一定要堅持！

五子棋的保存實際上並不是保存整個棋盤，而是通過一個叫做“稀疏數組”的結構來完成的。

稀疏數組，顧名思義是一個很稀疏的數組......

咳咳，稀疏數組實際上是一個只保存原始二維數組有效數據，去掉無效數據的一個二維數組。

它的處理方式是：

如果一個二維數組長這樣：

Hello 各位熱愛學習的小夥伴們大家好，今天來給大家聊聊五子棋遊戲的後臺實現。

可是你有想過五子棋的“保存棋局”和“續上局”是如何實現的嗎？

五子棋的數據結構描述

我們知道，五子棋有一個正方形棋盤，分別設有白子和黑子：

那麼這個五子棋盤就可以使用二維數組來描述，假設是一個 11 × 11 的二維數組：

int[][] chessArr = new int[11][11];

然後我們輸出一下：

for (int[] row : chessArr) {
\tfor (int data : row) {
\t\tSystem.out.printf("%d ", data);
\t}
\tSystem.out.println();
}

然後我們先來填幾顆棋子，模擬一個五子棋局，在代碼中，由於初始的二維數組中默認都是 0 ，那我們就可以考慮用 1 代表黑子，用 2 代表白子：

chessArr[1][2] = 1; // 黑子先行
chessArr[2][3] = 2; // 白子緊隨其後
chessArr[1][4] = 1; // 黑子欲形成橫向三連之勢
chessArr[1][3] = 2; // 白子“挺進大別山”斷了黑子的陰謀

再輸出，就可以看到黑子白子形成的“圍追堵截”之勢了，有沒有點懷念小時候的感覺？

棋盤的壓縮保存

接下來就是今天的正題！如果你已經看到這裡，一定要堅持！

五子棋的保存實際上並不是保存整個棋盤，而是通過一個叫做“稀疏數組”的結構來完成的。

稀疏數組，顧名思義是一個很稀疏的數組......

咳咳，稀疏數組實際上是一個只保存原始二維數組有效數據，去掉無效數據的一個二維數組。

它的處理方式是：

如果一個二維數組長這樣：

那麼用於保存它的稀疏數組就可以是這樣：

Hello 各位熱愛學習的小夥伴們大家好，今天來給大家聊聊五子棋遊戲的後臺實現。

可是你有想過五子棋的“保存棋局”和“續上局”是如何實現的嗎？

五子棋的數據結構描述

我們知道，五子棋有一個正方形棋盤，分別設有白子和黑子：

那麼這個五子棋盤就可以使用二維數組來描述，假設是一個 11 × 11 的二維數組：

int[][] chessArr = new int[11][11];

然後我們輸出一下：

for (int[] row : chessArr) {
\tfor (int data : row) {
\t\tSystem.out.printf("%d ", data);
\t}
\tSystem.out.println();
}

然後我們先來填幾顆棋子，模擬一個五子棋局，在代碼中，由於初始的二維數組中默認都是 0 ，那我們就可以考慮用 1 代表黑子，用 2 代表白子：

chessArr[1][2] = 1; // 黑子先行
chessArr[2][3] = 2; // 白子緊隨其後
chessArr[1][4] = 1; // 黑子欲形成橫向三連之勢
chessArr[1][3] = 2; // 白子“挺進大別山”斷了黑子的陰謀

再輸出，就可以看到黑子白子形成的“圍追堵截”之勢了，有沒有點懷念小時候的感覺？

棋盤的壓縮保存

接下來就是今天的正題！如果你已經看到這裡，一定要堅持！

五子棋的保存實際上並不是保存整個棋盤，而是通過一個叫做“稀疏數組”的結構來完成的。

稀疏數組，顧名思義是一個很稀疏的數組......

咳咳，稀疏數組實際上是一個只保存原始二維數組有效數據，去掉無效數據的一個二維數組。

它的處理方式是：

如果一個二維數組長這樣：

那麼用於保存它的稀疏數組就可以是這樣：

如上圖所示：稀疏數組有固定的三列，分別代表原始二維數組的行、列和值，但是第一行具有特殊的含義：稀疏數組的第一行存儲原始數組的行數、列數和有效數據個數，這三個信息。而從第二行（也就是[1]行）開始，才是真正的原始二維數組的有效數據。

是不是非常簡單？

稀疏數組保存五子棋的代碼實現

分析完了稀疏數組的數據結構，那麼我們就來通過代碼實現上面五子棋局的保存。

剛才的五子棋局是這樣的：

Hello 各位熱愛學習的小夥伴們大家好，今天來給大家聊聊五子棋遊戲的後臺實現。

可是你有想過五子棋的“保存棋局”和“續上局”是如何實現的嗎？

五子棋的數據結構描述

我們知道，五子棋有一個正方形棋盤，分別設有白子和黑子：

那麼這個五子棋盤就可以使用二維數組來描述，假設是一個 11 × 11 的二維數組：

int[][] chessArr = new int[11][11];

然後我們輸出一下：

for (int[] row : chessArr) {
\tfor (int data : row) {
\t\tSystem.out.printf("%d ", data);
\t}
\tSystem.out.println();
}

然後我們先來填幾顆棋子，模擬一個五子棋局，在代碼中，由於初始的二維數組中默認都是 0 ，那我們就可以考慮用 1 代表黑子，用 2 代表白子：

chessArr[1][2] = 1; // 黑子先行
chessArr[2][3] = 2; // 白子緊隨其後
chessArr[1][4] = 1; // 黑子欲形成橫向三連之勢
chessArr[1][3] = 2; // 白子“挺進大別山”斷了黑子的陰謀

再輸出，就可以看到黑子白子形成的“圍追堵截”之勢了，有沒有點懷念小時候的感覺？

棋盤的壓縮保存

接下來就是今天的正題！如果你已經看到這裡，一定要堅持！

五子棋的保存實際上並不是保存整個棋盤，而是通過一個叫做“稀疏數組”的結構來完成的。

稀疏數組，顧名思義是一個很稀疏的數組......

咳咳，稀疏數組實際上是一個只保存原始二維數組有效數據，去掉無效數據的一個二維數組。

它的處理方式是：

如果一個二維數組長這樣：

那麼用於保存它的稀疏數組就可以是這樣：

是不是非常簡單？

稀疏數組保存五子棋的代碼實現

分析完了稀疏數組的數據結構，那麼我們就來通過代碼實現上面五子棋局的保存。

剛才的五子棋局是這樣的：

那麼如何生成對應的稀疏數組呢？當然是先循環了......

首先要確定有多少個有效數據，這個是非常關鍵的：

int sum = 0;
for (int i = 0; i < chessArr.length; i++) {
\tfor (int j = 0; j < chessArr[0].length; j++) {
\t\tif (chessArr[i][j] != 0) {
\t\t\tsum++;
\t\t}
\t}
}

得到 sum 的原始二維數組有效數據有，我們就可以聲明這個稀疏數組了：

int[][] sparseArr = new int[sum + 1][3];

然後是將原始數組的行數、列數和 有效數據個數 放入稀疏數組的第一行：

sparseArr[0][0] = chessArr.length;
sparseArr[0][1] = chessArr[0].length;
sparseArr[0][2] = sum;

最後就是將原始數組中的非 0 數據存放到稀疏數組中

int sparseArrRow = 1;
for (int i = 0; i < chessArr.length; i++) {
\tfor (int j = 0; j < chessArr[0].length; j++) {
\t\tif (chessArr[i][j] != 0) {
\t\t\tsparseArr[sparseArrRow][0] = i;
\t\t\tsparseArr[sparseArrRow][1] = j;
\t\t\tsparseArr[sparseArrRow][2] = chessArr[i][j];
\t\t\tsparseArrRow++;
\t\t}
\t}
}

到這裡為止，就完成了對稀疏數組的創建和賦值，我們的二維數組也已經放入到了這個 “壓縮”了的二維數組——稀疏數組之中。那我們來輸出一下這個稀疏數組，看看是不是我們想要的內容：

Hello 各位熱愛學習的小夥伴們大家好，今天來給大家聊聊五子棋遊戲的後臺實現。

可是你有想過五子棋的“保存棋局”和“續上局”是如何實現的嗎？

五子棋的數據結構描述

我們知道，五子棋有一個正方形棋盤，分別設有白子和黑子：

那麼這個五子棋盤就可以使用二維數組來描述，假設是一個 11 × 11 的二維數組：

int[][] chessArr = new int[11][11];

然後我們輸出一下：

for (int[] row : chessArr) {
\tfor (int data : row) {
\t\tSystem.out.printf("%d ", data);
\t}
\tSystem.out.println();
}

然後我們先來填幾顆棋子，模擬一個五子棋局，在代碼中，由於初始的二維數組中默認都是 0 ，那我們就可以考慮用 1 代表黑子，用 2 代表白子：

chessArr[1][2] = 1; // 黑子先行
chessArr[2][3] = 2; // 白子緊隨其後
chessArr[1][4] = 1; // 黑子欲形成橫向三連之勢
chessArr[1][3] = 2; // 白子“挺進大別山”斷了黑子的陰謀

再輸出，就可以看到黑子白子形成的“圍追堵截”之勢了，有沒有點懷念小時候的感覺？

棋盤的壓縮保存

接下來就是今天的正題！如果你已經看到這裡，一定要堅持！

五子棋的保存實際上並不是保存整個棋盤，而是通過一個叫做“稀疏數組”的結構來完成的。

稀疏數組，顧名思義是一個很稀疏的數組......

咳咳，稀疏數組實際上是一個只保存原始二維數組有效數據，去掉無效數據的一個二維數組。

它的處理方式是：

如果一個二維數組長這樣：

那麼用於保存它的稀疏數組就可以是這樣：

是不是非常簡單？

稀疏數組保存五子棋的代碼實現

分析完了稀疏數組的數據結構，那麼我們就來通過代碼實現上面五子棋局的保存。

剛才的五子棋局是這樣的：

那麼如何生成對應的稀疏數組呢？當然是先循環了......

首先要確定有多少個有效數據，這個是非常關鍵的：

int sum = 0;
for (int i = 0; i < chessArr.length; i++) {
\tfor (int j = 0; j < chessArr[0].length; j++) {
\t\tif (chessArr[i][j] != 0) {
\t\t\tsum++;
\t\t}
\t}
}

得到 sum 的原始二維數組有效數據有，我們就可以聲明這個稀疏數組了：

int[][] sparseArr = new int[sum + 1][3];

然後是將原始數組的行數、列數和 有效數據個數 放入稀疏數組的第一行：

sparseArr[0][0] = chessArr.length;
sparseArr[0][1] = chessArr[0].length;
sparseArr[0][2] = sum;

最後就是將原始數組中的非 0 數據存放到稀疏數組中

int sparseArrRow = 1;
for (int i = 0; i < chessArr.length; i++) {
\tfor (int j = 0; j < chessArr[0].length; j++) {
\t\tif (chessArr[i][j] != 0) {
\t\t\tsparseArr[sparseArrRow][0] = i;
\t\t\tsparseArr[sparseArrRow][1] = j;
\t\t\tsparseArr[sparseArrRow][2] = chessArr[i][j];
\t\t\tsparseArrRow++;
\t\t}
\t}
}

完美！

五子棋的覆盤——稀疏數組還原原始二維數組

有了上面的經驗，下面的“小怪獸”就基本上不需要怎麼打了。

Hello 各位熱愛學習的小夥伴們大家好，今天來給大家聊聊五子棋遊戲的後臺實現。

可是你有想過五子棋的“保存棋局”和“續上局”是如何實現的嗎？

五子棋的數據結構描述

我們知道，五子棋有一個正方形棋盤，分別設有白子和黑子：

那麼這個五子棋盤就可以使用二維數組來描述，假設是一個 11 × 11 的二維數組：

int[][] chessArr = new int[11][11];

然後我們輸出一下：

for (int[] row : chessArr) {
\tfor (int data : row) {
\t\tSystem.out.printf("%d ", data);
\t}
\tSystem.out.println();
}

然後我們先來填幾顆棋子，模擬一個五子棋局，在代碼中，由於初始的二維數組中默認都是 0 ，那我們就可以考慮用 1 代表黑子，用 2 代表白子：

chessArr[1][2] = 1; // 黑子先行
chessArr[2][3] = 2; // 白子緊隨其後
chessArr[1][4] = 1; // 黑子欲形成橫向三連之勢
chessArr[1][3] = 2; // 白子“挺進大別山”斷了黑子的陰謀

再輸出，就可以看到黑子白子形成的“圍追堵截”之勢了，有沒有點懷念小時候的感覺？

棋盤的壓縮保存

接下來就是今天的正題！如果你已經看到這裡，一定要堅持！

五子棋的保存實際上並不是保存整個棋盤，而是通過一個叫做“稀疏數組”的結構來完成的。

稀疏數組，顧名思義是一個很稀疏的數組......

咳咳，稀疏數組實際上是一個只保存原始二維數組有效數據，去掉無效數據的一個二維數組。

它的處理方式是：

如果一個二維數組長這樣：

那麼用於保存它的稀疏數組就可以是這樣：

是不是非常簡單？

稀疏數組保存五子棋的代碼實現

分析完了稀疏數組的數據結構，那麼我們就來通過代碼實現上面五子棋局的保存。

剛才的五子棋局是這樣的：

那麼如何生成對應的稀疏數組呢？當然是先循環了......

首先要確定有多少個有效數據，這個是非常關鍵的：

int sum = 0;
for (int i = 0; i < chessArr.length; i++) {
\tfor (int j = 0; j < chessArr[0].length; j++) {
\t\tif (chessArr[i][j] != 0) {
\t\t\tsum++;
\t\t}
\t}
}

得到 sum 的原始二維數組有效數據有，我們就可以聲明這個稀疏數組了：

int[][] sparseArr = new int[sum + 1][3];

然後是將原始數組的行數、列數和 有效數據個數 放入稀疏數組的第一行：

sparseArr[0][0] = chessArr.length;
sparseArr[0][1] = chessArr[0].length;
sparseArr[0][2] = sum;

最後就是將原始數組中的非 0 數據存放到稀疏數組中

int sparseArrRow = 1;
for (int i = 0; i < chessArr.length; i++) {
\tfor (int j = 0; j < chessArr[0].length; j++) {
\t\tif (chessArr[i][j] != 0) {
\t\t\tsparseArr[sparseArrRow][0] = i;
\t\t\tsparseArr[sparseArrRow][1] = j;
\t\t\tsparseArr[sparseArrRow][2] = chessArr[i][j];
\t\t\tsparseArrRow++;
\t\t}
\t}
}

完美！

五子棋的覆盤——稀疏數組還原原始二維數組

有了上面的經驗，下面的“小怪獸”就基本上不需要怎麼打了。

廢話不多說，直接上代碼：

int[][] chessArr1 = new int[sparseArr[0][0]][sparseArr[0][1]];
for (int i = 1; i < sparseArr.length; i++) {
\tchessArr1[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
}

然後輸出：

Hello 各位熱愛學習的小夥伴們大家好，今天來給大家聊聊五子棋遊戲的後臺實現。

可是你有想過五子棋的“保存棋局”和“續上局”是如何實現的嗎？

五子棋的數據結構描述

我們知道，五子棋有一個正方形棋盤，分別設有白子和黑子：

那麼這個五子棋盤就可以使用二維數組來描述，假設是一個 11 × 11 的二維數組：

int[][] chessArr = new int[11][11];

然後我們輸出一下：

for (int[] row : chessArr) {
\tfor (int data : row) {
\t\tSystem.out.printf("%d ", data);
\t}
\tSystem.out.println();
}

然後我們先來填幾顆棋子，模擬一個五子棋局，在代碼中，由於初始的二維數組中默認都是 0 ，那我們就可以考慮用 1 代表黑子，用 2 代表白子：

chessArr[1][2] = 1; // 黑子先行
chessArr[2][3] = 2; // 白子緊隨其後
chessArr[1][4] = 1; // 黑子欲形成橫向三連之勢
chessArr[1][3] = 2; // 白子“挺進大別山”斷了黑子的陰謀

再輸出，就可以看到黑子白子形成的“圍追堵截”之勢了，有沒有點懷念小時候的感覺？

棋盤的壓縮保存

接下來就是今天的正題！如果你已經看到這裡，一定要堅持！

五子棋的保存實際上並不是保存整個棋盤，而是通過一個叫做“稀疏數組”的結構來完成的。

稀疏數組，顧名思義是一個很稀疏的數組......

咳咳，稀疏數組實際上是一個只保存原始二維數組有效數據，去掉無效數據的一個二維數組。

它的處理方式是：

如果一個二維數組長這樣：

那麼用於保存它的稀疏數組就可以是這樣：

是不是非常簡單？

稀疏數組保存五子棋的代碼實現

分析完了稀疏數組的數據結構，那麼我們就來通過代碼實現上面五子棋局的保存。

剛才的五子棋局是這樣的：

那麼如何生成對應的稀疏數組呢？當然是先循環了......

首先要確定有多少個有效數據，這個是非常關鍵的：

int sum = 0;
for (int i = 0; i < chessArr.length; i++) {
\tfor (int j = 0; j < chessArr[0].length; j++) {
\t\tif (chessArr[i][j] != 0) {
\t\t\tsum++;
\t\t}
\t}
}

得到 sum 的原始二維數組有效數據有，我們就可以聲明這個稀疏數組了：

int[][] sparseArr = new int[sum + 1][3];

然後是將原始數組的行數、列數和 有效數據個數 放入稀疏數組的第一行：

sparseArr[0][0] = chessArr.length;
sparseArr[0][1] = chessArr[0].length;
sparseArr[0][2] = sum;

最後就是將原始數組中的非 0 數據存放到稀疏數組中

int sparseArrRow = 1;
for (int i = 0; i < chessArr.length; i++) {
\tfor (int j = 0; j < chessArr[0].length; j++) {
\t\tif (chessArr[i][j] != 0) {
\t\t\tsparseArr[sparseArrRow][0] = i;
\t\t\tsparseArr[sparseArrRow][1] = j;
\t\t\tsparseArr[sparseArrRow][2] = chessArr[i][j];
\t\t\tsparseArrRow++;
\t\t}
\t}
}

完美！

五子棋的覆盤——稀疏數組還原原始二維數組

有了上面的經驗，下面的“小怪獸”就基本上不需要怎麼打了。

廢話不多說，直接上代碼：

int[][] chessArr1 = new int[sparseArr[0][0]][sparseArr[0][1]];
for (int i = 1; i < sparseArr.length; i++) {
\tchessArr1[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
}

然後輸出：