稀疏数组应用实例及代码实现

应用实例

1) 使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等)
2) 把稀疏数组存盘，并且可以从新恢复原来的二维数组数
3) 思路分析：
　　二维数组转稀疏数组的思路：
　　　　1、遍历原始二维数组，得到有效数据的个数 ：sum
　　　　2、根据sun就可以创建稀疏数组：sparseArr int[sum+1][3]
　　　　3、将二维数组的有效数据存入到稀疏数组

　　稀疏数组转原始二维数组的思路：
　　　　1、先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组。比如下方的chessArr=int[11][11]
　　　　2、在读取稀疏数组后几行的数据，并赋给原始的二维数组即可

4) 图示：

 

 代码实现

1. public static void main(String[] args) throws IOException {  
2.         //1.创建二维数组  
3.         int[][] chess = new int[11][11];  
4.         //2.创建棋盘上的棋子  
5.         chess[1][2] = 1;  
6.         chess[2][3] = 2;  
7.         chess[5][3] = 3;  
8.         chess[2][5] = 4;  
9.         chess[2][4] = 5;  
10.         //3.输出棋盘  
11.         System.out.println("输出二维数组：");  
12.         for (int[] row : chess) {  
13.             for (int data : row) {  
14.                 System.out.print(data + "\t");  
15.             }  
16.             System.out.println();  
17.         }  
18.         //4.获取二维数组中的有效数据个数sum  
19.         int sum = 0;  
20.         for (int[] row : chess) {  
21.             for (int data : row) {  
22.                 if (data != 0) {  
23.                     sum++;  
24.                 }  
25.             }  
26.         }  
27.         //5.创建稀疏数组  
28.         int[][] sparseArr = new int[sum + 1][3];  
29.         //6.第一行存入二维数组行列数和有效数据个数  
30.         sparseArr[0][0] = chess.length;  
31.         sparseArr[0][1] = chess[1].length;  
32.         sparseArr[0][2] = sum;  
33.         //7.将二维数组有效数据存入稀疏数组  
34.         int count = 0;//用来记录sparkArr中是第几个非零数据  
35.         for (int i = 0; i < chess.length; i++) {  
36.             for (int j = 0; j < chess[i].length; j++) {  
37.                 if (chess[i][j] != 0) {  
38.                     count++;  
39.                     sparseArr[count][0] = i;  
40.                     sparseArr[count][1] = j;  
41.                     sparseArr[count][2] = chess[i][j];  
42.                 }  
43.             }  
44.         }  
45.         //8.遍历稀疏数组  
46.         System.out.println("输出稀疏数组：");  
47.         for (int[] row : sparseArr) {  
48.             for (int data : row) {  
49.                 System.out.print(data + "\t");  
50.             }  
51.             System.out.println();  
52.         }  
53.         //9.将稀疏数组恢复成原始的二维数组，首先用稀疏数组的第一行数据，创建二维数组  
54.         int[][] chess2 = new int[sparseArr[0][0]][sparseArr[0][1]];  
55.         //10.将稀疏数组的每一行数据恢复到新的二维数组中去  
56.   
57.         for (int i = 1; i < sparseArr.length; i++) {  
58.             chess2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];  
59.         }  
60.         //11.输出新的二维数组  
61.         System.out.println("输出还原的二维数组：");  
62.         for (int[] row : chess2) {  
63.             for (int data : row) {  
64.                 System.out.print(data + "\t");  
65.             }  
66.             System.out.println();  
67.         }  
68. }