稀疏数组的学习心得

最新推荐文章于 2022-12-13 22:04:03 发布
最新推荐文章于 2022-12-13 22:04:03 发布
阅读量619 收藏 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();
		}

	}
}

运行结果如下：

《深入浅出AI》前言知识：深度学习基础总结
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
09-13 2140
本文详细介绍了深度学习的基础知识、主要概念和术语、以及经典的深度学习算法。深度学习是机器学习的一个分支，侧重于构建和训练神经网络以自动提取特征。文章探讨了深度学习的优缺点，比较了机器学习与深度学习的区别，并讨论了如卷积神经网络（CNN）、循环神经网络（RNN）、生成对抗网络（GANs）和深度强化学习（RL）等深度学习模型。此外，文中还介绍了如何使用深度学习进行手写数字识别任务，包括数据准备、网络配置、模型训练、评估和预测的步骤，并通过实例展示了整个流程。最后，分享自己精心制作的深度学习思维导图。
《深入浅出OCR》前言知识（二）：深度学习最新全面总结
最新发布
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
08-29 5205
本作者推出全新系列《深入浅出OCR》专栏，对标最全OCR教程。将分别从OCR技术发展、方向、概念、算法、论文、数据集等各种角度展开详细介绍。本篇为该专栏的前言知识，主要介绍深度学习知识，全面总结知知识点，方便小白或AI爱好者学习基础知识。
数据结构稀疏矩阵实验报告
11-14
稀疏矩阵 三元组单链表 结构体(行数、列数、头) 矩阵运算 重载运算符
稀疏矩阵_数据结构的实践心得（基于双向循环链表实现稀疏矩阵的动态管理：SparseMatrix）...
weixin_39990138的博客
11-29 248
头文件(SparseMatrix.h)：#pragma once#include "doubleLinkList.h"#define SparseMatrixDATASIZE 3#define ROWINDEX 0#define COLINDEX 1#define DATAINDEX 2typedef struct{ doubleLinkList doubleLink; // 矩阵双链表...
学习稀疏数组的心得与体会（java实现）
欢迎留言技术探讨
05-27 211
最近新学习了稀疏数组，对稀疏数组有了一个较为深刻的理解，稀疏数组可以将数据压缩存储，节省空间，之后需要时将数组解压即可。那么下面我们就来实现一下稀疏数组吧。 稀疏数组 我们先来说一下稀疏数组的概念： 记录原始二维数组的行列数，并记录原始二维数组中的值的个数并创建n行3列的数组，第一行记录原始二维数组的行列数和值的个数，其余各行记录值所在的行和列还有值的大小 下面我们用代码来进行实现 首先我们可以这样来想，我们可以把一个二维数组想象成一个n行n列的棋盘，那么我们用1来代表黑子，2来代表蓝子创建一个棋盘出来，
数据结构C语言版稀疏矩阵实验报告,晓庄-数据结构(C语言版)实验报告.doc
weixin_42129797的博客
05-19 469
晓庄-数据结构(C语言版)实验报告.doc数据结构C语言版 实验报告学院 信息工程学院 班级 行13软件工程 学号 13201607 姓名 蒋龙建 指导教师 曹晨 实验一 线性表基本操作和简单程序1 实验目的向一张空的顺序表和一个空的链表中插入若干个整数，以0表征输入结束，插入数据时需保持数据的递增有序，并且将第偶数次出现的数据从表中删除，每插入一个数据后，将表中元素依次进行输出。例如输入 6 输...
java_稀疏矩阵快速转置算法(+调试心得)
xuchaoxin1375的博客
03-10 1046
文章目录主类辅助功能类(读入任意规格的矩阵)编写和调试心得 主类 /* * @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
JS学习心得
m0_58356106的博客
08-11 2812
嘟嘟嘟嘟嘟嘟嘟嘟嘟嘟嘟
机器学习实战(基于scikit-learn和TensorFlow)学习心得(8)--SCIKIT-LEARN DESIGN
Tomswordyan的博客
02-26 597
原文及翻译: Scikit-Learn’s API is remarkably well designed. The main design principles are: Consistency. All objects share a consistent and simple interface: Scikit-Learning的API设计得非常好。主要的设计原则是： 一致性。所有对象共享一...
稀疏数组学习笔记
UNIQUE1627098817的博客
12-13 128
稀疏数组
数据结构C语言版稀疏矩阵实验报告,《数据结构 课程设计》稀疏矩阵实验报告.doc...
weixin_34036423的博客
05-19 1225
《数据结构 课程设计》稀疏矩阵实验报告目 录一、概述1二、 系统分析1三、 概要设计1(1)主界面的设计:2(2)系数矩阵的存储2(3)具体实现流程图：3四、详细设计4(2)稀疏矩阵的相加：5五、 运行与测试8六、 总结与心得8参考文献9源代码9一、概述稀疏矩阵的加法运算，既将稀疏矩阵A和B，他均为m行n列，分别以数组的形式存放在A和B中，实现A+B=C，将所得的结果存放在C数组中。系统分析...
稀疏矩阵的转置实践报告
12-29
数据结构作业哦 实验目的 （1）熟练掌握数组的基本操作； （2）理解稀疏矩阵的定义； （3）掌握稀疏矩阵的三元组存储结构的定义和基本操作的实现； （4）通过本章实验帮助学生加深对C语言的使用。
数据结构个人笔记 第13课 稀疏数组
mcyuuji的博客
11-01 365
数据结构个人笔记 第十五课 稀疏数组数组稀疏矩阵三元组顺序表代码实现行逻辑链接的顺序表代码实现十字链表法代码展示 数组 稀疏矩阵 稀疏矩阵的压缩存储，至少需要存储以下信息： 矩阵中各非0元素的值，以及所在矩阵中的行标和列标 矩阵的总行数和总列数 三元组顺序表 三元组压缩存储： 组中的数据分别表示（行标、列标、元素值） 在c语言中，三元组需要用结构体来实现 //三元体结构体 typedef struct{ int i ,j;//行标i,列标j int data; }triple; 由于稀疏矩阵
数据结构三元组实验报告_数据结构 实验五  稀疏矩阵的三元组实现实验
weixin_36138385的博客
12-31 2610
一、实验目的及要求：掌握稀疏矩阵的三元组表示方法、算法实现。二、实验内容：(1) 基于三元组的稀疏矩阵表示与输入、输出方法(必做)；(2) 基于三元组的稀疏矩阵加法(选做)；(3) 基于三元组表示的稀疏矩阵转置(选做)；(4) 基于三元组表示的稀疏矩阵的乘法(选做)。三、实验准备：1) 计算机设备；2) 程序调试环境的准备，如TC环境；3) 实验内容的算法分析与代码设计与分析准备。四、实验步骤和实...
3348数据结构实验之数组二：稀疏矩阵
让一让的博客
08-09 298
数据结构实验之数组二：稀疏矩阵 Time Limit: 5 ms Memory Limit: 1000 KiB Problem Description 对于一个n*n的稀疏矩阵M(1 &lt;= n &lt;= 1000)，采用三元组顺序表存储表示，查找从键盘输入的某个非零数据是否在稀疏矩阵中，如果存在则输出OK，不存在则输出ERROR。稀疏矩阵示例图如下： Input 连续输入多组数据...
稀疏数组的初步学习
qq_45022113的博客
06-22 131
稀疏数据初步学习 稀疏数组的介绍 当一个数组中大部分为0（造成资源的浪费），或者为同一值的数组时，可以使用稀疏数组来保存该数组 稀疏数据的处理方式 记录数组有几行几列，有多少个不同的值 把具有不同值得元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模 如下图：左边是原始数组，右边是稀疏数组 解析： 假设定义数组a[9]其中 a[0]表示原始数组有6行7列有8个不同的值 a[1]表示原始数组中22在0行3列的位置 a[2]表示原始数组中15在0行6列的位置 a[3]表示原始数组
ACM 学习心得
suamfadmp的博客
07-02 2297
ACM 学习心得STL：完美的艺术品STL 由四大部分组成：算法、容器、迭代器、仿函数。算法（algorithm）        算法定义了一组与实现无关的操作，也是 ACM 学习的核心。C++ 算法库的内容全都是一些比较基本的算法，包括移动、转换、遍历、删除、过滤等等。C++ 算法库本身是基于抽象的，在迭代器的抽象下，使得这些算法可以在不同结构的容器中重用。一个比较坑的地方就是我高中的时候学完 C
数据结构实验报告（稀疏矩阵）
12-18
数据结构实验报告稀疏矩阵，实验报告的模式，稀疏矩阵的运用
数据结构C语言版稀疏矩阵实验报告,数据结构稀疏矩阵基本运算实验报告..doc
weixin_35712811的博客
05-19 763
数据结构稀疏矩阵基本运算实验报告.课 程 设 计课程：数据结构题目：稀疏矩阵4 三元组单链表 结构体(行数、列数、头) 矩阵运算重载运算符 优班级：姓名：学号：设计时间：2010年1月17日——2010年5月XX日成绩：指导教师：楼建华一、题目题目稀疏矩阵4结构三元组单链表表示结构体(行数、列数、头)回传方式重载运算符操作矩阵运算二、概要设计1.存储结构typedef struct{int ...
稀疏矩阵实验报告（大学数据结构实验）
11-22
大学学数据结构一般都会接触到这个！！所以给大家分享下
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值