编写的五子棋程序中，有存盘、退出和续上盘的功能。

分析问题：

因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据，所以可以用稀疏数组来对这个二维数组进行一个压缩。

当一个数组中大部门元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方法是：

  1. 记录数组一共有几行几列，有多少个不同的值。
  2. 把具有不同值的元素的行列及值记录在一个小规模的数组（稀疏数组）中，从而缩小程序的规模。

​

第一张图为二维数组，一共有6行7列，第二张图是所对应的稀疏数组，第一行第一列记录原始数组有几行，第一行第二列记录原始数组有几列，第三列记录原始数组有多少个非0值，在原始数组里边有22、15、11、17、-6、39、91、28，共8个非0值，再后面的行记录的是每一个非0值的行列以及具体的值。所以原始数组为6×7=42的一个二维数组就变成了9×3=27的一个数组，42变成27，所以说起到了将原始数组规模变小的效果。

  1. 使用稀疏数组，来保留类似前面的二维数组（棋盘、地图等）
  2. 把稀疏数组存盘，并且可以从新恢复原来的二维数组
  3. 整体思路分析

二维数组转稀疏数组思路：

  • 遍历原始的二维数组，得到有效数据的个数sum

  • 根据sum就可以创建稀疏数组sparseArr

    1. int[sum+1][3]

  • 将二维数组的有效数据存入到稀疏数组中

稀疏数组转原始二维数组思路：

  • 先读取到稀疏数组的第一行，根据第一行的数据创建原始二维数组，比如上面的

    1. chessArr2 = int[11][11]

  • 再读取稀疏数组后几行的数据，并赋给原始的二维数组即可。

  1. 代码实现
  1. public class SparseArray {
  3. 	public static void main(String[] args) {
  4. 		// 创建一个原始的二维数组11x11
  5. 		//0：表示没有棋子，1：表示黑子，2：表示白子
  6. 		int chessArr1[][] = new int[11][11];
  7. 		chessArr1[1][2] = 1;
  8. 		chessArr1[2][3] = 2;
  9. 		//输出原始的二维数组
  10. 		System.out.println("原始的二维数组~~");
  11. 		for(int[] row : chessArr1) {
  12. 			for(int data : row) {
  13. 				System.out.printf("%d\t",data);
  14. 			}
  15. 			System.out.println();
  16. 		}
  17. 		//将二维数组转成稀疏数组
  18. 		//1、先遍历二维数组，得到非0数据的个数
  19. 		int sum = 0;
  20. 		for(int i = 0;i < 11;i ++) {
  21. 			for(int j = 0;j < 11;j ++) {
  22. 				if(chessArr1[i][j] != 0) {
  23. 					sum ++;
  24. 				}
  25. 			}
  26. 		}
  27. 		//2、创建对应的稀疏数组
  28. 		int sparseArr[][] = new int[sum+1][13];
  29. 		//3、给稀疏数组赋值
  30. 		sparseArr[0][0] = 11;
  31. 		sparseArr[0][1] = 11;
  32. 		sparseArr[0][2] = sum;
  33. 		//4、遍历二维数组，将非0的值存放到稀疏数组中
  34. 		int count = 0;//用于记录是第几个非0数据
  35. 		for(int i = 0;i < 11;i ++) {
  36. 			for(int j = 0;j < 11;j ++) {
  37. 				if(chessArr1[i][j] != 0) {
  38. 					count ++;
  39. 					sparseArr[count][0] = i;
  40. 					sparseArr[count][1] = j;
  41. 					sparseArr[count][2] = chessArr1[i][j];
  42. 				}
  43. 			}
  44. 		}
  45. 		//输出稀疏数组
  46. 		System.out.println();
  47. 		System.out.println("得到的稀疏数组~~");
  48. 		for (int i = 0;i < sparseArr.length;i ++) {
  49. 			System.out.printf("%d\t%d\t%d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
  50. 		}
  51. 		System.out.println();
  52. 		//5、将稀疏数组恢复到原始的二维数组
  53. 		//先读取到稀疏数组的第一行，根据第一行的数据创建原始二维数组
  54. 		//比如上面的  chessArr2 = int[11][11]
  55. 		int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
  56. 		//再读取稀疏数组后几行的数据(第二行开始)，并赋给原始的二维数组即可。
  57. 		for(int i = 1;i < sparseArr.length;i ++) {
  58. 			chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
  59. 		}
  60. 		//输出恢复后的二维数组
  61. 		System.out.println("恢复后的二维数组~~");
  62. 		for(int[] row : chessArr2) {
  63. 			for(int data : row) {
  64. 				System.out.printf("%d\t",data);
  65. 			}
  66. 			System.out.println();
  67. 		}
  68. 	}
  70. }

输出结果：

版权声明：本文为fxsenblog原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/fxsenblog/p/14522169.html