Java数据结构与算法——01 数据结构概述与稀疏数组实现

数据结构概述

数据结构包括线性结构与非线性结构。
线性结构的两种不同的存储结构：顺序存储结构(数组)和链式存储结构(链表)。
顺序存储的线性表为顺序表，即存储地址连续。
链式存储的线性表成为链表，存储地址不一定连续，元素节点中存放该节点数据以及相邻的节点存储地址。
线性结构常见的有:数组、链表、队列、栈
非线性结构:二维数组、多维数组、广义表、树结构、图结构

稀疏数组

如果一个原有数组中大部分是相同的元素，那么在存储时将相同的元素去掉形成一个新的特定的数组，并且新数组可以还原成原有数组，以此减少存储空间，这个新的特定数组就是稀疏数组。
下图是原始数组与稀疏数组的转换过程:

下面是java带吗对原始数组转换成稀疏数组存储在磁盘中，及从磁盘中读取稀疏数组转换为原始数组的功能:

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class SparseArrayTransform {

//将稀疏数组写入文件
public void saveArray(int[][] sparsearray) {

try {
FileWriter output = new FileWriter(new File("D:\\a.txt"));
for (int i = 0; i < sparsearray.length; i++) {
for (int j = 0; j < sparsearray[i].length; j++) {
output.write(sparsearray[i][j] + "\t");
}
output.write("\t\n");
}
output.close();

} catch (IOException e) {
e.printStackTrace();
}

}

//将稀疏数组读取出来
public int[][] readArrayFromFile(File f) {
int[][] array;
try {
BufferedReader br = new BufferedReader(new FileReader(f));
String line = br.readLine();
String[] temp = line.split("\t");
array = new int[Integer.valueOf(temp[0])][Integer.valueOf(temp[1])];
while (null != (line = br.readLine())) {
String[] t = line.split("\t");
int row = Integer.valueOf(t[0]);
int col = Integer.valueOf(t[1]);
array[row][col] = Integer.valueOf(t[2]);
}
return array;
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}

return null;
}

public int[][] changeToSparseArray(int[][] originalArray) {
int num = 0;
String s = "";
//先将数字个数以及每个数字位置与值记录下来到String中
for (int i = 0; i < originalArray.length; i++) {
for (int j = 0; j < originalArray[i].length; j++) {
if (originalArray[i][j] != 0) {

s = s + i + "\t" + j + "\t" + originalArray[i][j] + ";";
num++;
}
}
}
//根据数字个数创建稀疏数组，稀疏数组列是3，分别代表数字的行列值（第一列除外）
String[] array = s.split(";");
int[][] sparseArray = new int[array.length + 1][3];
int count = 0;
sparseArray[0][0] = originalArray.length;
sparseArray[0][1] = originalArray[0].length;
sparseArray[0][2] = num;
for (String v : array) {
count++;
String[] temp = v.split("\t");
int row = Integer.valueOf(temp[0]);
int col = Integer.valueOf(temp[1]);
int value = Integer.valueOf(temp[2]);
sparseArray[count][0] = row;
sparseArray[count][1] = col;
sparseArray[count][2] = value;
}

return sparseArray;
}

public int[][] changeToOriginalArray(int[][] sparseArray) {
//稀疏数组还原，按第一排数据创建数组，然后把数字按位置改好
int row = sparseArray[0][0];
int col = sparseArray[0][1];
int[][] originalArray = new int[row][col];
for (int i = 1; i < sparseArray.length; i++) {
int r = Integer.valueOf(sparseArray[i][0]);
int c = Integer.valueOf(sparseArray[i][1]);
int v = Integer.valueOf(sparseArray[i][2]);
originalArray[r][c] = v;
}
return originalArray;
}

public void printArray(int[][] array) {

for (int[] a : array) {
for (int s : a) {
System.out.print(s + "	");
}
System.out.println();
}
}

public static void main(String[] args) {

SparseArrayTransform satf = new SparseArrayTransform();
int[][] originalArray = new int[6][6];
originalArray[1][1] = 1;
originalArray[2][3] = 3;
originalArray[4][5] = 8;
System.out.println("原始数组：");
satf.printArray(originalArray);
int[][] sparseArray = satf.changeToSparseArray(originalArray);
System.out.println("稀疏数组：");
satf.printArray(sparseArray);
satf.saveArray(sparseArray);
originalArray = satf.readArrayFromFile(new File("D:\\a.txt"));
System.out.println("还原后的数组：");
satf.printArray(originalArray);
}

}

运行结果：

• 点赞
• 收藏
• 分享
• 文章举报