稀疏矩阵

时间：2017-06-21 22:01:26 阅读：235 评论：0 收藏：0 [点我收藏+]

标签：val 根据属性 com int back 扫描 orm name

文字描述

一、名词解释

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

}

提醒：稀疏矩阵的源码下载：

http://www.cnblogs.com/tanlon/p/4164295.html

稀疏矩阵

标签：val 根据属性 com int back 扫描 orm name

原文地址：http://www.cnblogs.com/lpd1/p/7061755.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行