java数据结构与算法学习（一）

1.稀疏数组

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

这个6x8的二维数组大部分都是0，需要存储的有效数值其实很少。如果我们直接以6x8的容量去存储该数组，将会浪费不少内存。

这个6x8的二维数组全是数值8，那么除了直接存储6x8的数组，我们还可以想象使用一个更简洁的存储方式吗？

由上述的几张图可以看出，直接存储它们将会浪费相当的内存。因此，我们便有了更简洁更节省的稀疏数组。

稀疏数组的处理方法是：
1）记录数组一共有几行( row )几列( col )，有多少个不同的值( value )。
2)把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模。

以上面的这张图为例，该图大部分是0。按照方法的步骤，我们可以先确定该数组一共有6行8列，值有5个。

然后将其转化为稀疏数组则是：

[0]: 表示原来数组的整体行数、列数、值
[1]: 表示第0行，第1列的值为9
[2]: 表示第1行，第6列的值为2
[3]: 表示第2行，第2列的值为4
[4]: 表示第4行，第1列的值为2
[5]: 表示第4行，第4列的值为1

如此一来，我们便将原先要存储的一个6 x 8的二维数组，转化为要存储一个6 x 3的数组，所占用的内存空间大大减少。

2.代码实现二维数组与稀疏数组之间的相互转化

二维数组 转化为 稀疏数组：

1. 遍历原始的二维数组，得到有效数据的个数sum；
2. 根据sum来创建稀疏数组sparseArr int[sum + 1][3]；
3. 将二维数组的有效数据存入到稀疏数组当中。

稀疏数组 转化为 二维数组：

1. 先读取稀疏数组的第一行，并根据第一行的数据，创建原始的二维数组
2. 再读取稀疏数组后几行的数据，并赋值给原始的二维数组

代码的具体实现如下：

package demo;

public class sparseArray {

	public static void main(String[] args) {
		
		/*****************************二维数组转化为稀疏数组**************************/
		//创建一个6 * 8的棋盘二维数组
		//int[] chessArr = int[6][8]; //错误原因：前者定义的chessArr是int型的一维数组，而后面赋值的是int型的二维数组，而且后者少了new这个关键字
		int[][] chessArr = new int[6][8];
		chessArr[0][1] = 9;
		chessArr[1][6] = 2;
		chessArr[2][2] = 4;
		chessArr[4][1] = 2;
		chessArr[4][4] = 1;
		
		//1.输出初始的棋盘
		/* 增强for循环的书写格式：
				for(variable : collection) statement
				 
				- 其中，variable用于暂存collection（集合）中的每一个元素，并执行相应的语句/语句块；
				而collection必须是一个数组，或者是一个实现了Iterable接口的类对象。
				*/
		System.out.println("原始的二维棋盘：");
		for (int[] row: chessArr) {
			for (int data: row) {
				//System.out.println(data); //此句仅打印每个data，运行时将是以一长列的数值展示
				System.out.printf("%d\t" ,data);
			}
			System.out.println("\n");
		}
		
		//2.遍历原始的二维数组，得到有效数据的个数sum
		int sum = 0;
		for (int i = 0; i < 6; i++) {
			for (int j = 0; j < 8; j++) {
				if(chessArr[i][j] != 0) {
					sum++;
				}
			}
		}
		
		//3.根据sum来创建稀疏数组sparseArr int[sum + 1][3]
		int[][] sparseArr = new int[sum + 1][3];
		sparseArr[0][0] = 6; //记录行数row
		sparseArr[0][1] = 8; //记录列数col
		sparseArr[0][2] = sum; //记录值value
		
		//4.将二维数组的有效数据存入到稀疏数组当中
		int counter = 0;
		for (int i = 0; i < 6; i++) {
			for (int j = 0; j < 8; j++) {
				if(chessArr[i][j] != 0) {
					sparseArr[counter + 1][0] = i;
					sparseArr[counter + 1][1] = j;
					sparseArr[counter + 1][2] = chessArr[i][j];
					counter++;
				}
			}
		}
		
		//5.打印出稀疏数组
		System.out.println("稀疏数组：");
		System.out.println();
		for(int i = 0; i < sum + 1; i++) {
			System.out.printf("%d\t %d\t %d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
		}
		
		
		/*****************************稀疏数组转化为二维数组**************************/
		
		//1.先读取稀疏数组的第一行，并根据第一行的数据，创建原始的二维数组
		int[][] chessArr2 =new int[sparseArr[0][0]][sparseArr[0][1]];
		
		//2.再读取稀疏数组后几行的数据，并赋值给原始的二维数组
		for (int i = 1; i < sparseArr.length; i++) {
			chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
		}
		
		//3.打印转化好的二维数组
		System.out.println("\n由稀疏数组转化而来的二维数组：");
		for(int[] cows: chessArr2) {
			for(int data: cows) {
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}
	}
}

运行结果：

————————————————————————————————————————————

下一篇
java数据结构与算法学习（二）