【轉載請註明出處: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();
}
}
打印結果如下：
