写在前面

闲话不想多说，接着总结，今天说的是稀疏矩阵三元组存储的顺序结构。

文字描述

一、名词解释

1、稀疏矩阵

矩阵阵中非零元素较少且分布的没有规律

2、三元组存储

矩阵中的一个元素有三个属性：行号，列号，元素的值，成为三元组

3、顺序结构

对于每一个三元组而已，根据行号优先或者列号优先排序起来，便于后期针对矩阵的运算

二、压缩与还原

1、压缩

逐行扫描矩阵，遇见非零元素就记录下来即可

2、还原

遍历顺序存储的数据，将每一个数据放入到矩阵的合适位置即可

代码实现

1、三元组抽象结构

package org.Stone6762.entity;

/**
 * @Stone6762
 */
public class TripleNode {

	/**
	 * @Fields row : TODO(该元素所在的行)
	 */
	private int row;

	/**
	 * @Fields column : TODO(该元素所在的列)
	 */

	private int column;

	/**
	 * @Fields value : TODO(该位置所储存的内容)
	 */
	private double value;

	/**
	 * @构造器
	 * @param row
	 * @param column
	 * @param value
	 */
	public TripleNode(int row, int column, double value) {
		super();
		this.row = row;
		this.column = column;
		this.value = value;
	}

	/**
	 * @构造器
	 */
	public TripleNode() {
		this(0, 0, 0);
	}

	public int getRow() {
		return row;
	}

	public void setRow(int row) {
		this.row = row;
	}

	public int getColumn() {
		return column;
	}

	public void setColumn(int column) {
		this.column = column;
	}

	public double getValue() {
		return value;
	}

	public void setValue(double value) {
		this.value = value;
	}

	@Override
	public String toString() {
		return "[ (" + row + "," + column + "), "
				+ value + " ]";
	}

}

2、三元组的顺序存储及其还原过程

import org.Stone6762.Utils.ArrayUtils;
import org.Stone6762.entity.TripleNode;

/**
 * @Stone6762
 */
public class SparseArray {

	/**
	 * @Fields data : TODO(储存数据的地方)
	 */
	private TripleNode data[];
	/**
	 * @Fields rows : TODO(原始数据的行数)
	 */
	private int rows;
	/**
	 * @Fields cols : TODO(原始数据的列数)
	 */
	private int cols;
	/**
	 * @Fields nums : TODO(现存数据的个数)
	 */
	private int nums;

	public TripleNode[] getData() {
		return data;
	}

	public void setData(TripleNode[] data) {
		this.data = data;
		this.nums = data.length;
	}

	public int getRows() {
		return rows;
	}

	public void setRows(int rows) {
		this.rows = rows;
	}

	public int getCols() {
		return cols;
	}

	public void setCols(int cols) {
		this.cols = cols;
	}

	public int getNums() {
		return nums;
	}

	public void setNums(int nums) {
		this.nums = nums;
	}

	public SparseArray() {
		super();
	}

	/**
	 * @构造器
	 * @param maxSize
	 */
	public SparseArray(int maxSize) {
		data = new TripleNode[maxSize];
		for (int i = 0; i < data.length; i++) {
			data[i] = new TripleNode();
		}
		rows = 0;
		cols = 0;
		nums = 0;
	}

	/**
	 * @构造器
	 * @param arr
	 */
	public SparseArray(double arr[][]) {
		this.rows = arr.length;
		this.cols = arr[0].length;
		// 统计有多少非零元素，以便于下面空间的申请
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr[0].length; j++) {
				if (arr[i][j] != 0) {
					nums++;
				}
			}
		}
		// 根据上面统计的非零数据的个数，将每一个非零元素的信息进行保存
		data = new TripleNode[nums];
		for (int i = 0, k = 0; i < arr.length; i++) {
			for (int j = 0; j < arr[0].length; j++) {
				if (arr[i][j] != 0) {
					data[k] = new TripleNode(i, j, arr[i][j]);
					k++;
				}
			}
		}
	}

	/**
	 * @Title: printArray
	 * @Description: TODO(打印储存后的稀疏矩阵)
	 */
	public void printArrayOfRC() {
		System.out.println("稀疏矩阵的三元组储存结构为：  ");
		System.out.println("行数" + rows + ", 列数为：" + cols + " ,非零元素个数为：  "
				+ nums);
		System.out.println("行下标           列下标         元素值     ");
		for (int i = 0; i < nums; i++) {
			System.out.println(" " + data[i].getRow() + "      "
					+ data[i].getColumn() + "     " + data[i].getValue());
		}
	}

	/**
	 * @Description: TODO( )
	 */
	public void printArr() {
		System.out.println("稀疏矩阵的三元组储存结构为：  ");
		System.out.println("行数" + rows + ", 列数为：" + cols + " ,非零元素个数为：  "
				+ nums);
		double origArr[][] = reBackToArr();
		ArrayUtils.printMulArray(origArr);
		
	}

	/**
	 * @Description: TODO(将稀疏矩阵还原成影视矩阵 )
	 * @return
	 */
	public double[][] reBackToArr() {
		double arr[][] = new double[rows][cols];
		for (int i = 0; i < nums; i++) {
			arr[data[i].getRow()][data[i].getColumn()] = data[i].getValue();
		}
		return arr;
	}

}