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);
	}

}

运行结果：