【转载请注明出处:From李诗雨—https://blog.csdn.net/cjm2484836553/article/details/91345761】
不诗意的女程序猿不是好厨师~
数据结构学习1-稀疏数组
1.一些基础点
1.1数据结构：包括线性结构和非线性结构。
1.2线性结构
- 特点是数据元素之间存在一对一的线性关系.
- 线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。
顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的。
链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。 - 线性结构常见的有：数组、队列、链表和栈。
1.3非线性结构
- 非线性结构包括：二维数组，多维数组，广义表，树结构，图结构
2.稀疏数组
2.1实际使用场景
举个栗子来说：
我们都玩过五子棋游戏，那么如果让我们自己撸起袖子来写一个，你会怎么做呢？用什么来表示棋盘棋子？黑棋白棋如何表示？如果下到一半累了不想玩了需要保存棋局该怎么做？打了局王者乏了又想来继续下五子棋，又该如何复局呢？
现在我们来分析一下，我们可以用一个11*11的二维数组来模拟棋局，二维数组的值来代表棋子，如果是1就表示是黑子，如果是2就表示是蓝子。
如果要实现保存棋盘的功能，就要把这个二维数组保存起来。
但是我们看现在这个二维数组有很多的0值，直接保存起来感觉很浪费。那有没有什么办法可以简化这个二维数组呢？
我们可以把它优化成如上图所示的二维数组，
第一行用来表示原有数组有几行几列吗，多少个不同的值。
从第二行开始每一行表示 行、列的位置 和对应的值。
所以数组2可以得到的信息是：
原有数组有11行11列有2个不同的值，其中在（1,2）位置的值是1，（2,3）位置的值是2。
看，其实就是对原有数组的另一种表示。而且我们把1111的规模编程了33的规模，是不是大大的做到了简化。
好的，不知不觉中我们就引入了稀疏数组，其实啊，简化后的数组就是一个稀疏数组。下面我们来看看什么是稀疏数组。
2.1稀疏数组的小结
当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方法是:
记录数组一共有几行几列，有多少个不同的值。
把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模。
3.学以致用，撸代码
现在让我们按下面的要求来撸一段代码，练习一下：
3.0利用稀疏数组完成棋局的保存和棋局的恢复功能。
分析：
先将如图所示的棋局，用1111的二维数组表示出来，然后把它转化为对应的稀疏数组，存储到本地文件中，这样就完成“棋局的保存”功能。
我们将文件中的内容读取出来，转化为稀疏数组，然后在转化为对应的1111的二维数组，这样就完成了“复盘”功能。
光说不练假把式，具体代码如下：
3.1用11*11的二维数组展示棋局。
/**
* 创建一个11*11的二维数组 ，来模拟五子棋棋盘
* 其中值1代表黑棋，棋2代表蓝棋
*/
int[][] gobangArray = new int[11][11];
gobangArray[1][2] = 1;
gobangArray[2][3] = 2;
System.out.println("原始棋局：");
for (int[] row : gobangArray) {
for (int element : row) {
System.out.printf("%d\t", element);
}
System.out.println();
}
打印结果如下：
3.2 将 原始数组 转化为 稀疏数组
具体思路：
a. 遍历 原始的二维数组，得到有效数据的个数 sum
b. 根据sum 创建 稀疏数组 sparseArray int[sum + 1] [3]
c. 将二维数组的有效数据数据存入到 稀疏数组
/**
* 遍历原始棋局，得到棋子总数
*/
int sum = 0;
for (int[] row : gobangArray) {
for (int element : row) {
if (element != 0) sum++;
}
}
/**
* 创建稀疏数组 int[sum+1][3]
* 第一行存原始棋局的行数，列数 和 棋子数
* 后面的每一行：第一列 存棋子的所在行下标，第二列 存棋子的所在列下标，第三列 存值
*/
int[][] sparseArray = new int[sum + 1][3];
sparseArray[0][0] = 11;
sparseArray[0][1] = 11;
sparseArray[0][2] = sum;
int sparseRow = 1;
for (int row = 0; row < 11; row++) {
for (int column = 0; column < 11; column++) {
if (gobangArray[row][column] != 0) {
sparseArray[sparseRow][0] = row;
sparseArray[sparseRow][1] = column;
sparseArray[sparseRow][2] = gobangArray[row][column];
sparseRow++;
}
}
}
/**
* 验证一下
*/
System.out.println();
System.out.println("稀疏数组为：");
for (int[] row : sparseArray) {
for (int element : row) {
System.out.printf("%d\t", element);
}
System.out.println();
}
打印结果如下：
3.3 将稀疏数组保存到本地的txt文件中
//将稀疏数组存入到文件中
File file = new File("e:\\array.txt"); //存放数组数据的文件
try {
FileWriter out = new FileWriter(file); //文件写入流
//将数组中的数据写入到文件中。每行各数据之间用TAB间隔
for(int i=0;i<sparseArray.length;i++){
for(int j=0;j<3;j++){
out.write(sparseArray[i][j]+"\t");
}
out.write("\r\n");
}
out.close();
} catch (Exception e) {
e.printStackTrace();
System.out.println("存入文件时出现异常："+e.getMessage().toString());
}
此时在本地的e盘下我们会发现多了一个array.txt文件，打开这个文件，发现存储正确。
哈哈，到此模拟 棋局的保存 功能就完成了。
3.4 从本地txt文件中读取数据，并转化为对应的稀疏数组。
/**
* 从txt文件中读取数据
*/
File txtFile = new File("e:\\array.txt");
int[][] txtSparseArr = new int[3][3];
try {
String line;//存放每行的数据
int row = 0;//记录行数
if (txtFile.exists()) {
BufferedReader in = new BufferedReader(new FileReader(txtFile));
while ((line = in.readLine()) != null) {
String[] temp = line.split("\t");
for (int j = 0; j < temp.length; j++) {
txtSparseArr[row][j] = Integer.parseInt(temp[j]);
}
row++;
}
} else {
System.out.println("没有找到文件");
}
} catch (Exception e) {
e.printStackTrace();
}
/**
* 验证一下
*/
System.out.println();
System.out.println("txt中得到的稀疏数组：");
for (int[] lineData : txtSparseArr) {
for (int ele : lineData) {
System.out.printf("%d\t", ele);
}
System.out.println();
}
打印结果如下：
3.5 将稀疏数组恢复为原始数组
具体思路：
a. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的 int[][] gobangArray2 = new int[11][11]。
b. 在读取稀疏数组后几行的数据，并赋给 原始的二维数组 即可。
/**
* 根据稀疏数组恢复棋局
* 遍历稀疏数组的每行，给新棋局进行赋值
*/
int row1 = txtSparseArr[0][0];
int column1 = txtSparseArr[0][1];
int[][] gobangArray2 = new int[row1][column1];
for (int i = 1; i < txtSparseArr.length; i++) {//需从第二行开始
int row2 = txtSparseArr[i][0];
int column2 = txtSparseArr[i][1];
int value = txtSparseArr[i][2];
gobangArray2[row2][column2] = value;
}
System.out.println();
System.out.println("复局后的新棋盘");
for (int[] row : gobangArray2) {
for (int element : row) {
System.out.printf("%d\t", element);
}
System.out.println();
}
打印结果如下：
这样 “恢复棋局” 功能也实现了。
思考：如果不知道txt中二维数组的行、列数呢？该如何处理？
我的想法是把txt中的每行数据都装进一个ArrayList中，这样ArrayList.size就是行数，每个行的内容进行拆分后形成的数组的长度就是列数。这样就可以创建稀疏数组了，然后遍历，把数据放入稀疏数组中。这样也可以把txt文件转换为二维数组了。
这个只是自己笨拙的思考，如果大佬有好的方法，希望可以告诉我一下哈。
File file5 = new File("e:\\array.txt");
ArrayList<String> txtData = new ArrayList<>();
try {
String line;
if (file5.exists()) {
BufferedReader in = new BufferedReader(new FileReader(file5));
while ((line = in.readLine()) != null) {
txtData.add(line);
}
} else {
System.out.println("没有找到文件");
}
} catch (Exception e) {
e.printStackTrace();
}
if (txtData != null && txtData.size() > 0) {
String[] firstLine = txtData.get(0).split("\t");
int rows = txtData.size();//得到行数
int columns = firstLine.length;//得到列数
int[][] sparseArray3 = new int[rows][columns];
for (int i = 0; i < txtData.size(); i++) {
String[] oneLine = txtData.get(i).split("\t");
//如果数组 sparseArray3 和 onLine 中的元素类型相同，则只要写此行就可以了
// sparseArray3[i] = oneLine;
for (int j = 0; j < oneLine.length; j++) {
sparseArray3[i][j] = Integer.parseInt(oneLine[j]);
}
}
System.out.println();
System.out.println("新方式得到的稀疏数组222：");
for (int[] lineData : sparseArray3) {
for (int ele : lineData) {
System.out.printf("%d\t", ele);
}
System.out.println();
}
}
打印结果如下：
