稀疏矩阵
1. 基本介绍
- 稀疏矩阵:数组存放很多没有意义的数据。
- 稀疏数组的处理方法:
(1)记录数组一共有几行几列,有多少个不同的值。
(2)把具有不同值的元素的行列及值记录在一个小规模的数组中,从而缩小程序的规模。
2. 思路分析
-
遍历原始的稀疏矩阵,得到有效的数据的个数
sum
。 -
根据
sum
就可以创建新数组newArray[sum + 1][3]
。 -
新数组的第一行存储稀疏数组的行数、列数、有效数个数。
-
之后的每一行存储有效数据的行数、列数、该有效数。
3. 代码实现
import java.io.*;
import java.util.Arrays;
public class SparseArray {
/**
* 得到一个初始数组
*/
public static int[][] getArray() {
int[][] array = new int[11][11];
array[1][2] = 1;
array[2][3] = 2;
array[4][5] = 9;
return array;
}
/**
* 恢复初始的稀疏数组
*/
public static int[][] getArray(int[][] newArray) {
// 获取原始数组的行列大小
int rows = newArray[0][0];
int cols = newArray[0][1];
int sum = newArray[0][2];
// 初始化原始数组
int[][] array = new int[rows][cols];
// 将有效数据恢复到稀疏数组中
for (int i = 1; i <= sum; i++) {
array[newArray[i][0]][newArray[i][1]] = newArray[i][2];
}
return array;
}
/**
* 将稀疏数组转化为新数组并落盘
*/
public static int[][] getNewArray(int[][] array) throws IOException {
// 获取行列信息
int rows = array.length;
int cols = array[0].length;
int sum = 0;
// 获取有效数字的个数
for (int[] row : array) {
for (int item : row) {
if (item != 0) {
sum++;
}
}
}
// 初始新数组
int[][] newArray = new int[sum + 1][3];
newArray[0][0] = rows;
newArray[0][1] = cols;
newArray[0][2] = sum;
int count = 0;
// 将有效数据的信息存储到新数组中
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
if (array[i][j] != 0) {
count++;
newArray[count][0] = i;
newArray[count][1] = j;
newArray[count][2] = array[i][j];
}
}
}
//将新数组落盘
saveNewArray(newArray);
return newArray;
}
/**
* 将新数组存入磁盘
*/
public static void saveNewArray(int[][] newArray) throws IOException {
// 获取字符输出流
FileWriter fw = new FileWriter(new File("/Users/zgl/Desktop/sparseArray.data"));
for (int[] row : newArray) {
// 换行写出
fw.write(Arrays.toString(row) + "\r\n");
}
// 关闭资源
fw.close();
}
/**
* 将保存的新数组从磁盘加载进内存
*/
public static int[][] loadNewArray() throws IOException {
// 获取字符输入流
FileReader fr = new FileReader(new File("/Users/zgl/Desktop/sparseArray.data"));
// 获取字符缓冲输入流
BufferedReader br = new BufferedReader(fr);
// 按行读取数据
String line = br.readLine();
String newLine = line.replace("[", "").replace("]", "").replaceAll(" ","");
String[] col = newLine.split(",");
// 初始化稀疏数组
int[][] sparseArray = new int[Integer.parseInt(col[2]) + 1][3];
int row = 0;
sparseArray[row][0] = Integer.parseInt(col[0]);
sparseArray[row][1] = Integer.parseInt(col[1]);
sparseArray[row][2] = Integer.parseInt(col[2]);
// 恢复稀疏数组的信息
while ((line = br.readLine()) != null) {
row++;
newLine = line.replace("[", "").replace("]", "").replaceAll(" ","");
System.out.println(newLine);
col = newLine.split(",");
sparseArray[row][0] = Integer.parseInt(col[0]);
sparseArray[row][1] = Integer.parseInt(col[1]);
sparseArray[row][2] = Integer.parseInt(col[2]);
}
// 关闭资源
br.close();
fr.close();
return sparseArray;
}
public static void main(String[] args) throws IOException {
// 1.得到一个初始数组
int[][] array = getArray();
System.out.println("原始数组为:");
for (int[] row : array) {
for (int item : row) {
System.out.printf("%d\t", item);
}
System.out.println();
}
// 2.获取初始数组对应的新数组
int[][] sparseArray = getNewArray(array);
System.out.println("转换后的新数组为:");
for (int[] row : sparseArray) {
for (int item : row) {
System.out.printf("%d\t", item);
}
System.out.println();
}
// 3.由新数组恢复初始的稀疏数组
int[][] array2 = getArray(loadNewArray());
System.out.println("由新数组恢复后的数组为:");
for (int[] row : array2) {
for (int item : row) {
System.out.printf("%d\t", item);
}
System.out.println();
}
}
}