稀疏数组的学习心得

最新推荐文章于 2022-04-01 16:30:41 发布
最新推荐文章于 2022-04-01 16:30:41 发布
阅读量550 收藏 1
点赞数
分类专栏： java 算法 数据结构 文章标签： 稀疏矩阵 围棋棋盘 存储优化 数据压缩 文件操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41983562/article/details/118525232
版权
java 同时被 3 个专栏收录
11 篇文章 0 订阅
订阅专栏
算法
6 篇文章 0 订阅
订阅专栏
数据结构
1 篇文章 0 订阅
订阅专栏

在一个使用二维数组保存围棋棋盘和还原围棋棋盘的过程来加深对稀疏矩阵的理解

如右图所示，将棋盘形象的表示为右边的二维数组，1表示黑子，2表示篮子

在这里插入图片描述

我们可以用右边的二维数组来保存这个数组，但是我们还可以用稀疏数组来表示这个二维数组，

它的好处就是减小了保存棋盘的数组大小，减小了棋盘复原的遍历时间

在这里插入图片描述

原理很简单，接下来直接上代码：

1.第一步：用二维数组将棋盘表示出来

package sparsearray;

import java.io.*;

/**
 * @filename SparseArray
 * @description 稀疏矩阵的实现
 * @action 压缩和恢复五子棋棋盘
 * @author market
 * @date 2021/7/6 9:08
 */
public class SparseArray {
	public static void main(String[] args) {
		//定义一个二维数组，1表示下黑子，2表示下蓝子,0表示空白
		int[][] chessArr = new int[11][11];
		chessArr[1][2] = 1;
		chessArr[2][3] = 2;
		System.out.println("初始二维数组的内容如下~~~~");
		for (int i = 0; i < 11; i++) {
			for (int j = 0; j < 11; j++) {
				System.out.print(chessArr[i][j] + "\t");
			}
			System.out.println();
		}

	}
}

输出结果如下：

2.第二步：将二维数组转换为稀疏数组

package sparsearray;

import java.io.*;

/**
 * @filename SparseArray
 * @description 稀疏矩阵的实现
 * @action 压缩和恢复五子棋棋盘
 * @author market
 * @date 2021/7/6 9:08
 */
public class SparseArray {
	public static void main(String[] args) {
		//定义一个二维数组，1表示下黑子，2表示下蓝子,0表示空白
		int[][] chessArr = new int[11][11];
		chessArr[1][2] = 1;
		chessArr[2][3] = 2;
		System.out.println("初始二维数组的内容如下~~~~");
		for (int i = 0; i < 11; i++) {
			for (int j = 0; j < 11; j++) {
				System.out.print(chessArr[i][j] + "\t");
			}
			System.out.println();
		}

		//获取元素二维数组中有多少个数据
		int sum = 0;
		for (int i = 0; i < 11; i++) {
			for (int j = 0; j < 11; j++) {
				if (chessArr[i][j]!=0){
					sum++;
				}
			}
		}

		//给稀疏数组赋值
		int sparseArr[][] = new int[sum+1][3];
		sparseArr[0][0] = chessArr.length;
		sparseArr[0][1] = chessArr[0].length;
		sparseArr[0][2] = sum;
		int count=0;
		for (int i = 0; i < chessArr.length; i++) {
			for (int j = 0; j < chessArr[0].length; j++) {
				if (chessArr[i][j]!=0){
					count++;
					sparseArr[count][0] = i;
					sparseArr[count][1] = j;
					sparseArr[count][2] = chessArr[i][j];
				}
			}
		}

		System.out.println("二维数组转为稀疏数组后的值~~~~~");
		for (int i = 0; i < sparseArr.length; i++) {
			System.out.print(sparseArr[i][0]+ "\t" +sparseArr[i][1]+ "\t" +sparseArr[i][2]+"\n");

	}
}

运行结果如下

3.第三步：将压缩后的稀疏数组存入map.data文件中（存档）

package sparsearray;

import java.io.*;

/**
 * @filename SparseArray
 * @description 稀疏矩阵的实现
 * @action 压缩和恢复五子棋棋盘
 * @author market
 * @date 2021/7/6 9:08
 */
public class SparseArray {
	public static void main(String[] args) {
		//定义一个二维数组，1表示下黑子，2表示下蓝子,0表示空白
		int[][] chessArr = new int[11][11];
		chessArr[1][2] = 1;
		chessArr[2][3] = 2;
		System.out.println("初始二维数组的内容如下~~~~");
		for (int i = 0; i < 11; i++) {
			for (int j = 0; j < 11; j++) {
				System.out.print(chessArr[i][j] + "\t");
			}
			System.out.println();
		}

		//获取元素二维数组中有多少个数据
		int sum = 0;
		for (int i = 0; i < 11; i++) {
			for (int j = 0; j < 11; j++) {
				if (chessArr[i][j]!=0){
					sum++;
				}
			}
		}

		//给稀疏数组赋值
		int sparseArr[][] = new int[sum+1][3];
		sparseArr[0][0] = chessArr.length;
		sparseArr[0][1] = chessArr[0].length;
		sparseArr[0][2] = sum;
		int count=0;
		for (int i = 0; i < chessArr.length; i++) {
			for (int j = 0; j < chessArr[0].length; j++) {
				if (chessArr[i][j]!=0){
					count++;
					sparseArr[count][0] = i;
					sparseArr[count][1] = j;
					sparseArr[count][2] = chessArr[i][j];
				}
			}
		}

		System.out.println("二维数组转为稀疏数组后的值~~~~~");
		for (int i = 0; i < sparseArr.length; i++) {
			System.out.print(sparseArr[i][0]+ "\t" +sparseArr[i][1]+ "\t" +sparseArr[i][2]+"\n");
		}

		//将二维数组存入map.data文件中
		try {
			FileOutputStream outputStream = new FileOutputStream("map.data");
			for (int i = 0; i < sparseArr.length; i++) {
				outputStream.write((sparseArr[i][0]+"\t").getBytes());
				outputStream.write((sparseArr[i][1]+"\t").getBytes());
				outputStream.write((sparseArr[i][2]+"\n").getBytes());

			}
		} catch (FileNotFoundException e) {
			System.out.println("文件异常~~~~");
			e.printStackTrace();
		}catch (IOException e){
			System.out.println("写入异常~~~~");
			e.printStackTrace();
		}

	}
}

保存结果map.data文件中

4.第四步：读取文件（读盘）

package sparsearray;

import java.io.*;

/**
 * @filename SparseArray
 * @description 稀疏矩阵的实现
 * @action 压缩和恢复五子棋棋盘
 * @author market
 * @date 2021/7/6 9:08
 */
public class SparseArray {
	public static void main(String[] args) {
		//定义一个二维数组，1表示下黑子，2表示下蓝子,0表示空白
		int[][] chessArr = new int[11][11];
		chessArr[1][2] = 1;
		chessArr[2][3] = 2;
		System.out.println("初始二维数组的内容如下~~~~");
		for (int i = 0; i < 11; i++) {
			for (int j = 0; j < 11; j++) {
				System.out.print(chessArr[i][j] + "\t");
			}
			System.out.println();
		}

		//获取元素二维数组中有多少个数据
		int sum = 0;
		for (int i = 0; i < 11; i++) {
			for (int j = 0; j < 11; j++) {
				if (chessArr[i][j]!=0){
					sum++;
				}
			}
		}

		//给稀疏数组赋值
		int sparseArr[][] = new int[sum+1][3];
		sparseArr[0][0] = chessArr.length;
		sparseArr[0][1] = chessArr[0].length;
		sparseArr[0][2] = sum;
		int count=0;
		for (int i = 0; i < chessArr.length; i++) {
			for (int j = 0; j < chessArr[0].length; j++) {
				if (chessArr[i][j]!=0){
					count++;
					sparseArr[count][0] = i;
					sparseArr[count][1] = j;
					sparseArr[count][2] = chessArr[i][j];
				}
			}
		}

		System.out.println("二维数组转为稀疏数组后的值~~~~~");
		for (int i = 0; i < sparseArr.length; i++) {
			System.out.print(sparseArr[i][0]+ "\t" +sparseArr[i][1]+ "\t" +sparseArr[i][2]+"\n");
		}

		//将二维数组存入map.data文件中
		try {
			FileOutputStream outputStream = new FileOutputStream("map.data");
			for (int i = 0; i < sparseArr.length; i++) {
				outputStream.write((sparseArr[i][0]+"\t").getBytes());
				outputStream.write((sparseArr[i][1]+"\t").getBytes());
				outputStream.write((sparseArr[i][2]+"\n").getBytes());

			}
		} catch (FileNotFoundException e) {
			System.out.println("文件异常~~~~");
			e.printStackTrace();
		}catch (IOException e){
			System.out.println("写入异常~~~~");
			e.printStackTrace();
		}

		//还原数组，读取map.data文件
		File file = new File("map.data");
		byte b[] = new byte[(int)file.length()];
		try {
			FileInputStream inputStream = new FileInputStream(file);
			inputStream.read(b);
			inputStream.close();
		} catch (FileNotFoundException e) {
			System.out.println("文件异常~~~~");
			e.printStackTrace();
		}catch (IOException e){
			System.out.println("写入异常~~~~");
			e.printStackTrace();
		}
		String data = new String(b);
		String[] rowStr = data.split("\n");
		String[] colStrLen = rowStr[0].split("\t");
		int[][] sparseArr2 = new int[rowStr.length][colStrLen.length];
		for (int i = 0; i < rowStr.length; i++) {
			String[] colStr = rowStr[i].split("\t");
			for (int j = 0; j < colStr.length; j++) {
				Integer integer = Integer.valueOf(colStr[j]);
				sparseArr2[i][j] = integer;
			}
		}
		System.out.println("从map.data文件中读取出来的数据转为稀疏数组后的值~~~~");
		for (int i = 0; i < sparseArr2.length; i++) {
			System.out.print(sparseArr2[i][0]+ "\t" +sparseArr2[i][1]+ "\t" +sparseArr2[i][2]+"\n");
		}

	}
}

运行结果如下

5.第五步：将稀疏数组还原为二维数组

package sparsearray;

import java.io.*;

/**
 * @filename SparseArray
 * @description 稀疏矩阵的实现
 * @action 压缩和恢复五子棋棋盘
 * @author market
 * @date 2021/7/6 9:08
 */
public class SparseArray {
	public static void main(String[] args) {
		//定义一个二维数组，1表示下黑子，2表示下蓝子,0表示空白
		int[][] chessArr = new int[11][11];
		chessArr[1][2] = 1;
		chessArr[2][3] = 2;
		System.out.println("初始二维数组的内容如下~~~~");
		for (int i = 0; i < 11; i++) {
			for (int j = 0; j < 11; j++) {
				System.out.print(chessArr[i][j] + "\t");
			}
			System.out.println();
		}

		//获取元素二维数组中有多少个数据
		int sum = 0;
		for (int i = 0; i < 11; i++) {
			for (int j = 0; j < 11; j++) {
				if (chessArr[i][j]!=0){
					sum++;
				}
			}
		}

		//给稀疏数组赋值
		int sparseArr[][] = new int[sum+1][3];
		sparseArr[0][0] = chessArr.length;
		sparseArr[0][1] = chessArr[0].length;
		sparseArr[0][2] = sum;
		int count=0;
		for (int i = 0; i < chessArr.length; i++) {
			for (int j = 0; j < chessArr[0].length; j++) {
				if (chessArr[i][j]!=0){
					count++;
					sparseArr[count][0] = i;
					sparseArr[count][1] = j;
					sparseArr[count][2] = chessArr[i][j];
				}
			}
		}

		System.out.println("二维数组转为稀疏数组后的值~~~~~");
		for (int i = 0; i < sparseArr.length; i++) {
			System.out.print(sparseArr[i][0]+ "\t" +sparseArr[i][1]+ "\t" +sparseArr[i][2]+"\n");
		}

		//将二维数组存入map.data文件中
		try {
			FileOutputStream outputStream = new FileOutputStream("map.data");
			for (int i = 0; i < sparseArr.length; i++) {
				outputStream.write((sparseArr[i][0]+"\t").getBytes());
				outputStream.write((sparseArr[i][1]+"\t").getBytes());
				outputStream.write((sparseArr[i][2]+"\n").getBytes());

			}
		} catch (FileNotFoundException e) {
			System.out.println("文件异常~~~~");
			e.printStackTrace();
		}catch (IOException e){
			System.out.println("写入异常~~~~");
			e.printStackTrace();
		}

		//还原数组，读取map.data文件
		File file = new File("map.data");
		byte b[] = new byte[(int)file.length()];
		try {
			FileInputStream inputStream = new FileInputStream(file);
			inputStream.read(b);
			inputStream.close();
		} catch (FileNotFoundException e) {
			System.out.println("文件异常~~~~");
			e.printStackTrace();
		}catch (IOException e){
			System.out.println("写入异常~~~~");
			e.printStackTrace();
		}
		String data = new String(b);
		String[] rowStr = data.split("\n");
		String[] colStrLen = rowStr[0].split("\t");
		int[][] sparseArr2 = new int[rowStr.length][colStrLen.length];
		for (int i = 0; i < rowStr.length; i++) {
			String[] colStr = rowStr[i].split("\t");
			for (int j = 0; j < colStr.length; j++) {
				Integer integer = Integer.valueOf(colStr[j]);
				sparseArr2[i][j] = integer;
			}
		}
		System.out.println("从map.data文件中读取出来的数据转为稀疏数组后的值~~~~");
		for (int i = 0; i < sparseArr2.length; i++) {
			System.out.print(sparseArr2[i][0]+ "\t" +sparseArr2[i][1]+ "\t" +sparseArr2[i][2]+"\n");
		}

		//将稀疏数组还原为二维数组
		int[][] chessArr2 = new int[sparseArr2[0][0]][sparseArr2[0][1]];
		for (int i = 1; i < sparseArr2.length; i++) {
			chessArr2[sparseArr2[i][0]][sparseArr2[i][1]] = sparseArr2[i][2];
		}

		System.out.println("将稀疏数组还原为二维数组后的值~~~~");
		for (int i = 0; i < 11; i++) {
			for (int j = 0; j < 11; j++) {
				System.out.print(chessArr2[i][j] + "\t");
			}
			System.out.println();
		}

	}
}

运行结果如下：

代码的马
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构三元组实验报告_数据结构 实验五  稀疏矩阵的三元组实现实验
weixin_36138385的博客
12-31 2548
一、实验目的及要求：掌握稀疏矩阵的三元组表示方法、算法实现。二、实验内容：(1) 基于三元组的稀疏矩阵表示与输入、输出方法(必做)；(2) 基于三元组的稀疏矩阵加法(选做)；(3) 基于三元组表示的稀疏矩阵转置(选做)；(4) 基于三元组表示的稀疏矩阵的乘法(选做)。三、实验准备：1) 计算机设备；2) 程序调试环境的准备，如TC环境；3) 实验内容的算法分析与代码设计与分析准备。四、实验步骤和实...
c语言三元组稀疏矩阵的转置实验报告,稀疏矩阵三元组实现矩阵转置算法实验报告.doc...
weixin_39880623的博客
05-19 1152
稀疏矩阵三元组实现矩阵转置算法实验报告.doc 1实验三稀疏矩阵的三元组表示实现矩阵转置算法学院专业班学号姓名一．实习目的1掌握稀疏矩阵的三元组顺序表存储表示；2掌握稀疏矩阵三元组表示的传统转置算法的实现；3掌握稀疏矩阵三元组表示的快速转置算法的实现；二．实习内容1稀疏矩阵的按三元组形式输入，即按行序输入非零元的行号、列号、值，实现传统转置算法，输出按通常的阵列形式输出。2稀疏矩阵的按三元组形式输...
数据结构--稀疏矩阵转置（列序递增算法）的c语言实现（超详细注释/实验报告）
池塘春草梦的博客
10-29 5198
稀疏矩阵是指矩阵中大多数元素为零的矩阵。从直观上讲，当非零元素个数低于总元素的30%时，这样的矩阵为稀疏矩阵。
java_稀疏矩阵快速转置算法(+调试心得)
xuchaoxin1375的博客
03-10 1009
文章目录主类辅助功能类(读入任意规格的矩阵)编写和调试心得 主类 /* * @Description: * @Version: 2.0 * @Author: xuchaoxin * @Date: 2021-03-09 19:27:00 * @LastEditors: xuchaoxin * @LastEditTime: 2021-03-10 20:47:09 */ import java.util.ArrayList; import java.util.TreeMap; /** * @Author
数据结构实验报告 稀疏矩阵加源码
12-30
以一维数组顺序存放非零元素的行号、列号、和数值，行号以-1作为结束标志。实现A、B个数组相加，此矩阵放于第C个数组中,解决讲一个稀疏矩阵对应存于一个一维数组中，然后进行矩阵加法运算时依次扫描矩阵A和矩阵B的行列值，以行优先，当行列相同时，第三个元素值相加的和以及行列号三个元素存入结果数组中，不相同时，把A或B的三个元素直接存入结果数组中。
c语言稀疏矩阵转置实验报告,稀疏矩阵三元组实现矩阵转置算法实验报告
weixin_42221297的博客
05-18 984
《稀疏矩阵三元组实现矩阵转置算法实验报告》由会员分享，可在线阅读，更多相关《稀疏矩阵三元组实现矩阵转置算法实验报告(5页珍藏版)》请在人人文库网上搜索。1、实验三稀疏矩阵的三元组表示实现矩阵转置算法学院专业班学号姓名一. 实习目的1. 掌握稀疏矩阵的三元组顺序表存储表示；2. 掌握稀疏矩阵三元组表示的传统转置算法的实现；3. 掌握稀疏矩阵三元组表示的快速转置算法的实现；二. 实习内容1. 稀疏矩阵...
数据结构课程设计稀疏矩阵相加与相乘
07-01
常见的稀疏矩阵存储结构有链表、二维数组以及压缩存储（如压缩三元组存储和十字链表）。 1. **稀疏矩阵的相加**： 稀疏矩阵相加的基本思路是对两个稀疏矩阵的非零元素进行逐个相加。首先，需要确保两个矩阵具有...
数据结构实验报告-图的遍历.doc
07-11
实验的目标是理解和掌握图的逻辑结构（如邻接矩阵和邻接表）以及它们在内存中的物理表示，同时学习如何构造图，以及在两种存储方式下执行基本操作的算法。 1. **邻接矩阵**：图的邻接矩阵是一种二维数组，其中的...
数据结构实验报告。doc
05-10
而学号为双号的学生，使用邻接表，适合处理稀疏图，即顶点间连接较少的情况，空间利用率高。 四、算法实现 1. 邻接矩阵实现DFS： - 通过一个二维数组表示图，初始化一个访问标志数组，用于标记顶点是否已被访问。 ...
数据结构试验报告图试验.docx
11-19
邻接矩阵是一种用于表示图中顶点间边的二维数组。如果图是无向的，邻接矩阵是对称的，即arc[i][j] = arc[j][i]，表示顶点i到顶点j以及顶点j到顶点i都存在边。对于有向图，arc[i][j]为1表示有一条从顶点i到顶点j的边...
稀疏矩阵实验报告（大学数据结构实验）
11-22
大学学数据结构一般都会接触到这个！！所以给大家分享下
社会网络分析系统的设计和实现数据结构-课程设计学士学位论文.doc
最新发布
07-01
社会网络分析系统的实现需要使用到的技术包括数据挖掘、机器学习、网络分析等。 2. 数据结构的应用： 数据结构是计算机科学的基础，包括数组、链表、栈、队列、树、图等。这些数据结构可以用于社会网络分析系统的...
实验2.1 稀疏矩阵转置
杳杳_柒的博客
06-29 1846
#include<stdio.h> typedef struct { int r; int c; int v; }Triple; int main() { int m,n,i=0,j=0; scanf("%d%d",&m,&n); Triple A[130000]; for(;;) { int r...
数据结构课设——一元稀疏多项式的计算（单链表的应用）
DEAR_CXN的博客
01-19 4590
问题描述 能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减，并将结果输出； 算法思想        构建一个式子的结构体，包括系数，指数和指针域。分别输入各项的系数和指数，按照指数降序的方式存入到结构体链表中；输出多项式时，多项式为0，系数为1或是负数和指数为0或1，还有是否是最后一个式子的情况，都需要分别讨论；多项式相加即是若指数相等，则系数直接相加，不等则考虑将指数较...
用链表实现一元稀疏多项式相加
qq_52747920的博客
03-18 1469
学习分享 用链表表示多项式时，每个链表结点存储多项式中的一个非零项，包括系数（coef）和指数（expn）两个数据域以及一个指针域（next）。 对应的数据结构定义为 typedef struct PNode{ float coef; int expn; struct PNode *next; }PNode,*Polynomial; 定义完数据结构后我们要创建一个链表并进行相应的初始化，然后在输入时还应该将链表中元素进行排序，排序的原则通过比较多项式的指数expn来进行。 代码如下 //单个多项式指
稀疏数组转置
qq_41678405的博客
05-07 196
#include&lt;stdio.h&gt;#define MAXSIZE 12500typedef struct{    int i,j;//非零元素的行号，列号    int e;//非零元素的值}Triple;typedef struct{    Triple data[MAXSIZE+1];//非零元素三元组，data[0]未用    int mu,nu,tu;//矩阵的行数，列数，非零...
c语言三元组稀疏矩阵的转置实验报告,稀疏矩阵快速转置 数据结构实验报告
weixin_28733777的博客
05-19 1247
南昌航空大学实验报告课程名称： 数据结构 实验名称： 实验五 稀疏矩阵的存储和快速转置 班 级： 学生姓名： 学号： 指导教师评定： 签 名:题目：假设稀疏矩阵A采用三元组表表示，编写程序实现该矩阵的快速转置 要求：输入一个稀疏矩阵A，由程序将其转换成三元组表存储...
西工大NOJ数据结构实验——2.1稀疏矩阵转置
a15735748145a的博客
04-01 4766
西工大NOJ数据结构实验——2.1稀疏矩阵转置
使用js完成把稀疏数组变为不稀疏数组
05-25
可以使用 JavaScript 中的 `Array.prototype.filter()` 方法来将稀疏数组变为不稀疏数组。 例如，假设有以下稀疏数组： ```js const sparseArray = [1, , 2, , , 3]; ``` 可以使用 `filter()` 方法过滤掉数组中的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值