数据结构与算法（Java描述）-15、稀疏矩阵以及稀疏矩阵的三元组实现

一、稀疏矩阵

对一个m×n的矩阵，设s为矩阵元素个数的总和，有s=m*n，设t为矩阵中非零元素个数的总和，满足t＜＜s的矩阵称作稀疏矩阵。符号“＜＜”读作小于小于。简单说，稀疏矩阵就是非零元素个数远远小于元素个数的矩阵。相对于稀疏矩阵来说，一个不稀疏的矩阵也称作稠密矩阵。

二、稀疏矩阵的压缩存储

稀疏矩阵的压缩存储方法，是只存储矩阵中的非零元素。
稀疏矩阵中每个非零元素及其对应的行下标和列下标构成一个三元组，稀疏矩阵中所有这样的三元组构成一个以三元组为数据元素的线性表。

稀疏矩阵和对应的三元组线性表

稀疏矩阵的压缩存储结构主要有三元组的数组结构存储和三元组的链表结构存储两大类型。三元组的数组结构存储就是把稀疏矩阵的所有三元组按某种规则存储在一个一维数组中。三元组的链表结构存储就是把稀疏矩阵的所有三元组存储在一个链表中

数组结构的稀疏矩阵类：

三元组的数组结构存储，就是把所有三元组存储在一个数组中。

链式结构稀疏矩阵：

稀疏矩阵的所有三元组也可采用链表结构存储。用链表存储的稀疏矩阵三元组简称三元组链表。在三元组链表中每个结点的数据域由稀疏矩阵非零元的行号、列号和元素值组成。

带头节点的三元链表结构

三、三元组稀疏矩阵压缩算法的实现

//三元组类
public class Three {

	//行数
	public int row;
	//列数
	public int col;
	//值
	public double value;
	
	public Three(int row,int col,double value) {
		this.row=row;
		this.col=col;
		this.value=value;
	}
	public Three() {
		this(0,0, 0);
	}
	
}

import java.util.ArrayList;
import java.util.List;

//稀疏矩阵的压缩算法
public class SpanMartrix {

	//行数
	public int rows;
	//列数
	public int cols;
	//非零元素个数
	public int dNum;
	
	List<Three> list;
	
	public SpanMartrix(int max) {
		rows=cols=dNum=0;
		list=new ArrayList<>(max);
	}
	
	//根据用户传来的三元组类数组来初始化稀疏矩阵
	public void evaluate(int rows,int cols,int dNum,Three three[]) {
		this.rows=rows;
		this.cols=cols;
		this.dNum=dNum;
		for (int i = 0; i < dNum; i++) {
			list.add(i,three[i]);
		}
	}
	
	//打印稀疏矩阵
	public void printSpanMartrix() {
		System.out.println("行数："+this.rows);
		System.out.println("列数："+this.cols);
		System.out.println("非零元素个数："+this.dNum);
		System.out.println("三元组类：");
		for (int i = 0; i < dNum; i++) {
			System.out.println("martrix<"+list.get(i).row+","+list.get(i).col+">="+list.get(i).value);
		}
	}
	
	//矩阵的转置
	public SpanMartrix transport() {
		SpanMartrix newMartrix=new SpanMartrix(list.size());
		newMartrix.rows=this.cols;
		newMartrix.cols=this.rows;
		newMartrix.dNum=this.dNum;
		for(int i=0;i<dNum;i++) {
			Three three=list.get(i);
			newMartrix.list.add(new Three(three.col,three.row,three.value));
		}
		
		return newMartrix;
	}
	
}

测试：

public class SpanMain {

	public static void main(String[] args) {
		SpanMartrix mar1=new SpanMartrix(10);
		SpanMartrix mar2;
		Three three[]= new Three[6];
		three[0]= new Three(1,3,11.0);
		three[1]= new Three(1,5,17.0);
		three[2]= new Three(2,2,25.0);
		three[3]= new Three(4,1,19.0);
		three[4]= new Three(5,4,37.0);
		three[5]= new Three(6,7,50.0);
		
		mar1.evaluate(6, 7, 6, three);
		System.out.println("原矩阵..............");
		mar1.printSpanMartrix();
		System.out.println("转置之后的矩阵.........");
		mar2=mar1.transport();
		mar2.printSpanMartrix();
	}
}

数据结构与算法（Java描述）-15、稀疏矩阵以及稀疏矩阵的三元组实现

猜你喜欢