数据结构Java实现——④数组——>稀疏矩阵三元组顺序存储

作者信息

写在前面

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

文字描述

一、名词解释

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

}

时间: 2024-10-10 21:22:55

数据结构Java实现——④数组——>稀疏矩阵三元组顺序存储的相关文章

数据结构Java实现——④数组—&gt;稀疏矩阵三元组顺序存储--&gt;矩阵的倒置

作者信息 文字描述 倒置:把矩阵A的行换成相应的列,得到的新矩阵称为A的转置矩阵,记作AT或A. 通常矩阵的第一列作为转置矩阵的第一行,第一行作为转置矩阵的第一列. 那么,在已经存储好的三元组的顺序存储结构中,如果如何实现矩阵的倒置呢??? 第一反应肯定是直接遍历,然后行列对换即可,但是因为要求按照行号优先(也可以是列号优先,但是必须倒置前和倒置后都按照一种优先的方式排列),所以如果直接对换,那么就会变得没有顺序,还需要一次排序,这样反而不妙. 1.正常倒置 既然要进行行列对换,那么对换后的行号

看数据结构写代码(20)稀疏矩阵(顺序存储方式)

当矩阵 的 有用信息非常少时,我们考虑将矩阵压缩存储.这就涉及到 特殊矩阵 和 稀疏矩阵. 特殊矩阵 指的是 有一定规律的 矩阵,这个矩阵 我们 只存储 部分 有用信息,其余的信息 可以通过 公式 转换 求得.例如 对称矩阵,我们按行存储主对角线以下(包括主对角线)的元素,其余元素 我们可以通过 下面的公式求得. 稀疏矩阵,指的事没有一定规律的矩阵,并且  有用信息总数/矩阵总数 小于等于 0.05 的时候,我们称之为 稀疏矩阵. 下面的代码,给出了 稀疏矩阵的 "行逻辑链接的顺序存储"

数据结构实践项目——数组和广义表

本文针对 [数据结构基础系列网络课程(5):数组和广义表] 1. 数组的基本概念与存储结构 2. 特殊矩阵的压缩存储 3. 稀疏矩阵的三元组表示 4. 稀疏矩阵的十字链表表示 5. 广义表 6. 广义表的存储结构及基本运算的实现 [项目1 - 猴子选大王(数组版)] 一群猴子,编号是1,2,3 -m,这群猴子(m个)按照1-m的顺序围坐一圈.从第1只开始数,每数到第n个,该猴子就要离开此圈,这样依次下来,最后一只出圈的猴子为大王.输入m和n,输出猴子离开圈子的顺序,从中也可以看出最后为大王是几号

数据结构Java实现05----栈:顺序栈和链式堆栈

数据结构Java实现05----栈:顺序栈和链式堆栈 一.堆栈的基本概念: 堆栈(也简称作栈)是一种特殊的线性表,堆栈的数据元素以及数据元素间的逻辑关系和线性表完全相同,其差别是线性表允许在任意位置进行插入和删除操作,而堆栈只允许在固定一端进行插入和删除操作. 先进后出:堆栈中允许进行插入和删除操作的一端称为栈顶,另一端称为栈底.堆栈的插入和删除操作通常称为进栈或入栈,堆栈的删除操作通常称为出栈或退栈. 备注:栈本身就是一个线性表,所以我们之前讨论过线性表的顺序存储和链式存储,对于栈来说,同样适

数据结构Java实现07----队列:顺序队列&amp;顺序循环队列、链式队列、顺序优先队列

数据结构Java实现07----队列:顺序队列&顺序循环队列.链式队列.顺序优先队列 一.队列的概念: 队列(简称作队,Queue)也是一种特殊的线性表,队列的数据元素以及数据元素间的逻辑关系和线性表完全相同,其差别是线性表允许在任意位置插入和删除,而队列只允许在其一端进行插入操作在其另一端进行删除操作. 队列中允许进行插入操作的一端称为队尾,允许进行删除操作的一端称为队头.队列的插入操作通常称作入队列,队列的删除操作通常称作出队列. 下图是一个依次向队列中插入数据元素a0,a1,...,an-

SDUT 3347 数据结构实验之数组三:快速转置

数据结构实验之数组三:快速转置 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 转置运算是一种最简单的矩阵运算,对于一个m*n的矩阵M( 1 = < m < = 10000,1 = < n < = 10000 ),它的转置矩阵T是一个n*m的矩阵,且T( i , j )=M( j , i ).显然,一个稀疏矩阵的转置仍然是稀疏矩阵.你的任务是对给定一个m*n的稀疏矩阵( m

数据结构(Java描述)之线性表

基础概念 数据结构:是相互之间存在一种或多种关系的数据元素的集合. 逻辑结构和物理结构 关于数据结构,我们可以从逻辑结构和物理结构这两个维度去描述 逻辑结构是数据对象中数据元素之间的关系,是从逻辑意义上去描述的数据之间的组织形式. 逻辑结构有4种: 集合结构(数据元素之间仅以集合的方式体现,元素之间没有别的关系) 线性结构(数据元素之间存在一对一的关系) 树(数据元素之间为一对多或多对一的关系) 图(数据元素之间为多对多的关系) 物理结构则是逻辑结构在计算机中内存中的存储形式,分为两种: 顺序存

java的数组和链表

数组和链表 java的数组是什么:数组是用来存放同一种数据类型的集合, 数组中每个元素都是相通的数据类型,数组就是在内存中划分一串连续的空间(数组作为对象允许使用new关键字进行内存分配),注意只能存放同一种数据类型(Object类型数组除外),数组是一种数据结构 举个栗子:string:就是char类型的数组. 为什么要学数组:因为数组可以存放许多相同的数据类型!!编写程序时省去了很多代码量!! 怎么使用数组: 第一种方式: 数据类型 []  数组名称 = new 数据类型[数组长度]; 这里

数据结构4(数组和广义表)

第4章  数组和广义表 [例4-1]二维数组A的每一个元素是由6个字符组成的串,其行下标i=0,1,…,8,列下标j=1,2,…,10.若A以行为主序存储元素,A[8][5]的物理地址与当A按列为主序存储时的元素(  )的物理地址相同.设每个字符占一个字节. A.A[8][5]    B.A[3][10]    C.A[5][8]    D.A[0][9] //作图 解:  二维数A是一个9行10列的矩阵,即A[9][10].按行存储时,A[8][5]是第85个元素存储的元素.而按列存储时,第8