數據結構和算法（1）-----稀疏數組

一、實際需求

編寫的五子棋程序中，有存盤退出和繼續上盤的功能。

分析問題：因爲該二維數組的很多值是默認值0，因此記錄了很多沒有意思的數據，如何在計算機中高效的存儲這樣的二維數組是一個需要考慮的問題。

二、基本介紹

當一個數組中大部分元素爲0，或者爲同一個值的數組時，可以使用稀疏數組來保存該數組。

稀疏數組的處理方法是：

• 記錄數組一共有幾行幾列，有多少個不同的值
• 把具有不同值的元素的行列及值記錄在一個小規模的數組中，從而縮小程序的規模

示意圖：

三、應用實例

（1）使用稀疏數組，來保留類似前面的二維數組（棋盤，地圖等等）

（2）把稀疏數組存盤，並且可以重新恢復原來的二維數組

（3）整體思路分析

（4）代碼實現：

• 將原始的二維數組轉成稀疏矩陣，並保存在磁盤上，比如sqc.data
• 恢復原來的數組時，讀取sqc.data進行恢復

package com.atguigu.sparsearray;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class SparseArrayDemo {
	public static void main(String[] args) {
		//創建一個原始的二維數組11*11，其中0表示沒有棋子，1表示黑色棋子，2表示藍色棋子
		int [][] chessArr1=new int [11][11];
		chessArr1[1][2]=1;
		chessArr1[2][3]=2;
		
		
		//打印原始的二維數組
		System.out.println("原始的二維數組：");
		for(int i=0;i<11;i++){
			for(int j=0;j<11;j++){
				System.out.print(chessArr1[i][j]+"\t");
			}
			System.out.println();
		}
		
		
		//將二維數組轉成稀疏數組
		int count=0;
		int [] x=new int [121];
		int [] y=new int [121];
		for(int i=0;i<11;i++){
			for(int j=0;j<11;j++){
				if(chessArr1[i][j]!=0){
					x[count]=i;
					y[count]=j;
					count++;
				}
			}
		}
		int [][] sparseArr=new int [count+1][3];
		sparseArr[0][0]=11;
		sparseArr[0][1]=11;
		sparseArr[0][2]=count;
		for(int i=0;i<count;i++){
			sparseArr[i+1][0]=x[i];
			sparseArr[i+1][1]=y[i];
			sparseArr[i+1][2]=chessArr1[x[i]][y[i]];
		}
		
		
		//打印稀疏數組
		System.out.println("原始的稀疏數組：");
		for(int i=0;i<count+1;i++){
			for(int j=0;j<3;j++){
				System.out.print(sparseArr[i][j]+"\t");
			}
			System.out.println();
		}
		
		
		//將稀疏數組保存到磁盤中的文件
		File file =new File("I:/sqc.data");
		FileOutputStream fos=null;
		DataOutputStream dos=null;
		try {
			fos=new FileOutputStream(file);
			dos=new DataOutputStream(fos);
			for(int i=0;i<count+1;i++){
				for(int j=0;j<3;j++){
					dos.writeInt(sparseArr[i][j]);
				}
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(fos!=null){
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(dos!=null){
				try {
					dos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
		
		//從磁盤中的文件讀取稀疏數組
		FileInputStream fis=null;
		DataInputStream dis=null;
		try {
			fis=new FileInputStream(file);
			dis=new DataInputStream(fis);
			int [] temp=new int [3*(count+1)];
			for(int i=0;i<3*(count+1);i++){
				temp[i]=dis.readInt();
			}
			int [][] sparseArr1=new int [count+1][3];
			int c=0;
			for(int i=0;i<count+1;i++){
				for(int j=0;j<3;j++){
					sparseArr1[i][j]=temp[c++];
				}
			}
			//打印從磁盤中讀取的稀疏數組
			System.out.println("文件中讀取的稀疏數組：");
			for(int i=0;i<count+1;i++){
				for(int j=0;j<3;j++){
					System.out.print(sparseArr1[i][j]+"\t");
				}
				System.out.println();
			}
			//將磁盤中讀取的稀疏數組轉成原始的二維數組
			int [][] chessArr2=new int [sparseArr1[0][0]][sparseArr1[0][1]];
			for(int i=0;i<sparseArr1[0][2];i++){
				chessArr2[sparseArr1[i+1][0]][sparseArr1[i+1][1]]=sparseArr1[i+1][2];
			}
			//打印由稀疏數組轉換的二維數組
			System.out.println("文件中讀取的原始數組：");
			for(int i=0;i<11;i++){
				for(int j=0;j<11;j++){
					System.out.print(chessArr2[i][j]+"\t");
				}
				System.out.println();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(fis!=null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(dis!=null){
				try {
					dis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

效果圖：