稀疏数组day01

最新推荐文章于 2025-07-19 17:57:40 发布
最新推荐文章于 2025-07-19 17:57:40 发布
阅读量173 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构复习 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zero_ko/article/details/106865286
本文介绍稀疏数组的概念，通过示例演示如何将二维数组转换为稀疏数组，以及如何将稀疏数组恢复为原始二维数组。此外，文章还讲解了如何使用Java的FileWriter和FileReader进行文件的读写操作，实现稀疏数组的磁盘存储和恢复。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

线性结构

线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系
线性机构有两种不同的存储结构，即顺序存储（数组）和链式存储（链表）。
顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的
链式存储的线性表称为链表，链表中的存储元素不一定是连续的
线性结构常见的有：数组、队列、栈和链表。

非线性结构

非线性结构包括：二维数组、多维数组、广义表、树、图

稀疏数组

在这里插入图片描述
在这里插入图片描述

package com.xhl.sparsearray;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

public class SparseArray {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建一个原始的二维数组
		//0：表示没有棋子 1：表示黑子 2： 表示蓝子
		int chessArr1[][] = new int[11][11];
		chessArr1[1][2]=1;
		chessArr1[2][3]=2;
		chessArr1[4][5]=2;
		//输出原始 的二维数组
		System.out.println("原始的二维数组：");
		for(int[] row:chessArr1) {
			for(int data: row) {
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}
		
		//将二维数组转为稀疏数组
		//1、先遍历二维数组，得到非0数据个数
		int sum = 0;
		for(int i=0 ;i<11;i++) {
			for(int j = 0;j<11;j++) {
				if(chessArr1[i][j]!=0) {
					sum++;
				}
			}
		}
		
		//2、创建对应的稀疏数组
		int sparseArr[][] = new int[sum+1][3];
		//给稀疏数组赋值
		sparseArr[0][0]=11;
		sparseArr[0][1]=11;
		sparseArr[0][2]=sum;
		//遍历二维数组，将非0的值存放到sparseArr中
		int count = 0;//用于记录是第几个非0数据
		for(int i=0 ;i<11 && count<sum;i++) {
			for(int j = 0;j<11 && count<sum;j++) {
				if(chessArr1[i][j] !=0) {
					count ++;
					sparseArr[count][0]=i;
					sparseArr[count][1]=j;
					sparseArr[count][2]=chessArr1[i][j];
				}
			}
		}
		
		
		//输出稀疏数组的形式
		System.out.println();
		System.out.println("得到的稀疏数组为：");
		for(int i=0;i< sparseArr.length;i++) {
			System.out.printf("%d\t%d\t%d\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);			
		}
		System.out.println();
		
		
		//将稀疏数组--->恢复成原始的二维数组
		/*
		 * 1、先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
		 * 2、在读取稀疏数组的后几行数据，并赋值给二维数组即可
		 */
		
		//1、先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
		
		int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
		
		//2、在读取稀疏数组的后几行数据，并赋值给二维数组即可
		for(int i=1;i<sparseArr.length;i++) {
			chessArr2[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
		}
		
		//输出恢复后的二维数组
		System.out.println();
		System.out.println("恢复后的二维数组为；");
		
		for(int[] row:chessArr2) {
			for(int data: row) {
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}
	}
	
}

运行结果：
在这里插入图片描述
课后练习：

  • 将稀疏数组保存到磁盘上,文件名map.data
  • 读取map.data恢复稀疏数组

知识点：文件及IO流

在这里插入图片描述
在这里插入图片描述
图中FileReader属于节点流，Reader就是处理流

package com.xhl.sparsearray.homework;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class SparseArray {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建一个原始的二维数组
		//0：表示没有棋子 1：表示黑子 2： 表示蓝子
		int chessArr1[][] = new int[11][11];
		chessArr1[1][2]=1;
		chessArr1[2][3]=2;
		chessArr1[4][5]=2;
		//输出原始 的二维数组
		System.out.println("原始的二维数组：");
		for(int[] row:chessArr1) {
			for(int data: row) {
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}
		
		//将二维数组转为稀疏数组
		//1、先遍历二维数组，得到非0数据个数
		int sum = 0;
		for(int i=0 ;i<11;i++) {
			for(int j = 0;j<11;j++) {
				if(chessArr1[i][j]!=0) {
					sum++;
				}
			}
		}
		
		//2、创建对应的稀疏数组
		int sparseArr[][] = new int[sum+1][3];
		//给稀疏数组赋值
		sparseArr[0][0]=11;
		sparseArr[0][1]=11;
		sparseArr[0][2]=sum;
		//遍历二维数组，将非0的值存放到sparseArr中
		int count = 0;//用于记录是第几个非0数据
		for(int i=0 ;i<11 && count<sum;i++) {
			for(int j = 0;j<11 && count<sum;j++) {
				if(chessArr1[i][j] !=0) {
					count ++;
					sparseArr[count][0]=i;
					sparseArr[count][1]=j;
					sparseArr[count][2]=chessArr1[i][j];
				}
			}
		}
		
		//创建输出流
		FileWriter writer = null;
		
		try {
			writer = new FileWriter("map.data");
			//输出稀疏数组的形式
			System.out.println();
			System.out.println("得到的稀疏数组为：");
			for(int i=0;i< sparseArr.length;i++) {
				System.out.printf("%d\t%d\t%d\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
				
				//利用IO流将稀疏数组写入
				if (i == sparseArr.length - 1) {
					writer.append(sparseArr[i][0] + "," + sparseArr[i][1] + "," + sparseArr[i][2]);					
				}else {
					writer.append(sparseArr[i][0] + "," + sparseArr[i][1] + "," + sparseArr[i][2] + ",");										
				}
			}
			System.out.println();
			writer.flush();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			if(writer != null) {
				try {
					writer.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
				
		//将稀疏数组--->恢复成原始的二维数组
		/*
		 * 1、先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
		 * 2、在读取稀疏数组的后几行数据，并赋值给二维数组即可
		 */
		
		//1、先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
		
		FileReader reader = null;
		
		StringBuffer sb = new StringBuffer();
		try {
			reader = new FileReader("map.data");
			while (reader.ready()) {
				sb.append((char) reader.read());// 转成char加到StringBuffer对象中
			}
			System.out.println(sb.toString());
			reader.close();// 关闭读取流
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			try {
				if(reader != null) {
					reader.close();
				}
			}catch (IOException e){
				e.printStackTrace();
			}
		}
		
		String[] str = sb.toString().split(",");
		int chessArr2[][] = new int[str.length/3][3];
		// 给稀疏数组赋值
		int i = 0;
		for (String s : str) {
			chessArr2[(i - (i % 3)) / 3][i % 3] = Integer.parseInt(s);
			i++;
		}
		
		
		
		//输出恢复后的二维数组
		System.out.println();
		System.out.println("恢复后的二维数组为；");
		
		for(int[] row:chessArr2) {
			for(int data: row) {
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}
	}
	
}

运行结果：
在这里插入图片描述

数据结构与算法day02-稀疏数组与二维数组互换(五子棋问题)
深耕java的博客
11-16 261
基本介绍： 当一个数组中大部分元素为0，或者为同一个值的数组时， 可以使用稀疏数组来保存该数组 编写的五子棋程序中，有存盘退出和续上盘的功能 分析问题： 因为该二维数组的很多值是默认值0，因此**记录了很多没有意义的的数据**，需要使用到 稀疏数组来压缩数据大小 稀疏数组的处理方法是(如下图所示)： 1.记录数组一共有几行几列，有多少个不同的值 2.把具有不同值的元素的行列及值记录在一个小规模的数组中(小规模数组指稀疏数组)， 从而缩小程序的规模。 结果：从6*7=42大小的规模的二
新星计划Day4【数据结构与算法】 稀疏数组与队列
qq_46272491的博客
04-28 2185
新星计划Day4【数据结构与算法】 稀疏数组与队列 👩‍💻博客主页：京与旧铺的博客主页 ✨欢迎关注🖱点赞🎀收藏⭐留言✒ 🔮本文由京与旧铺原创，csdn首发！ 😘系列专栏：java学习 💻首发时间：🎞2022年4月28日🎠 🎨你做三四月的事，八九月就会有答案，一起加油吧 🀄如果觉得博主的文章还不错的话，请三连支持一下博主哦 🎧最后的话，作者是一个新人，在很多方面还做的不好，欢迎大佬指正，一起学习哦，冲冲冲 🛒导航小助手🎪 文章目录新星计划Day4【数据结构与算法】 稀疏数组与队列在这里插入图片描述🛒导
Day01稀疏数组学习
发发的博客
12-28 366
稀疏数组 写在前面 相关代码工程链接：点击这里 一、实际需求 二、基本介绍 当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存改数组！ 稀疏数组的处理方式： 1)记录数组一共有几行几列，有多少个不同的值 2)把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模 三、应用实例 1)使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等) 2)把稀疏数组存盘，并且可以从新恢复原来的二维数组数 3)整体思路分析 4)代码实现 SparseArry.java p
Day01稀疏数组
泷苏羽的博客
03-17 2181
** Day01稀疏数组 ** 1. 关于稀疏数组的引入 一般来说我们设计一个五子棋盘除去棋子之后，会空留很多空闲的点，这些多余的点是无意义的，我们可以引入一个新的概念——稀疏数组来处理这些无意义的点。 2. 稀疏数组 稀疏数组第一行， row col val 0 11 11 2 分别储存了这个二维数组的整体，11行11列共有2个有效值。 而第一个有效数字存储在第1列第2行（注意由二维数组的规则拥有0行0列）， 同理第二个有效数字储存在第2列第3行。 ...
Attays类 冒泡排序 稀疏数组 day 10
2301_81744437的博客
07-08 206
【代码】Attays类 冒泡排序 稀疏数组 day 10。
Java语言实现稀疏数组
Java厂长
02-21 261
稀疏数组 关于作者 作者介绍 ???? 博客主页：作者主页 ???? 简介：JAVA领域优质创作者????、一名在校大三学生????、在校期间参加各种省赛、国赛，斩获一系列荣誉???? ???? 关注我：关注我学习资料、文档下载统统都有，每日定时更新文章，励志做一名JAVA资深程序猿????‍???? 文章目录稀疏数组关于作者基本介绍应用实例图解代码实现课后练习 在编写的五子棋程序中，有存盘退出和续上盘的功能。 我们发现每次程序启动之后它的棋子还可以是之前的位置，这是怎么实现的，今天我们来探究
day18 稀疏数组的创建和还原
卓越小Y
03-01 105
稀疏数组 记录有效值的坐标跟值 当一个数组大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。 稀疏数组处理方式： 记录数组一共有几行几列，有多少个不同值 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序规模。 如图 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p8BKZLLM-1646094194934)(1645884023838.png)] 操作步骤 如何压缩成稀疏数组 先统计数组中有多少个元素 再创建稀疏数组 行 列 值，行
Day17：java数组（稀疏数组）
h1776842314的博客
02-02 190
JAVA数组以及稀疏数组例题
java稀疏数组
weixin_48722092的博客
08-07 152
package zhuang.come.day.Arrays; /* 稀疏数组 当一个数组中的大部分元素为0时，或者为同一个值得数组时，可以用稀疏数组 来保存该数组 稀疏数组的处理方式是： 1、记录数组一共有几行几列，有多少个不同值。 2、把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序 的规模。 */ public class Demo04 { public static void main(String[] args) { int[][] array =...
Day18-稀疏数组
Zhang_Fangbo的博客
11-15 498
稀疏数组 package array; public class Demo07 { public static void main(String[] args) { //1、创建一个二维数组11*11，0：没有棋子，1：黑棋，2：白棋。 int[][] array1 = new int[11][11]; array1[1][2] = 1; array1[2][3] = 2; System.out.println("输
Day4 java数组的学习与稀疏数组
qq_45411646的博客
09-18 280
Day4 java数组的学习
day23 Java基础——数组详解
Qhumaing的博客
08-17 1142
1. 数组的概述 2. 数组的声明和创建 2.1 声明数组 2.2 创建数组 2.3 内存分析 2.4 数组的三种初始化 静态初始化 动态初始化 数组的默认初始化 3. 数组的使用 3.1 访问数组元素 3.2 数组的遍历 3.3 数组的复制 3.4 数组的排序 3.5 数组的搜索 4. 多维数组 4.1 声明多维数组 4.2 创建多维数组 4.3 访问多维数组元素 4.4 多维数组的遍历 4.5 多维数组的复制 4.6 多维数组的排序 4.7 注意事项 5. Arrays类 5.1 排序 5.2 二分搜索
Day11-【软考】数据结构与算法中，如何计算一维数组、二维数组？
weixin_48146444的博客
01-11 404
如果按行存储，第一个元素a[0] [0]，第二个元素a[0] [1]，就是第0行的第1个元素。在操作系统中，有一个点，是页面置换算法，缺页的问题，要结合按行存储和按列存储来综合讨论。a[2] [3]是存储时的第14个元素，因为编号是从0开始算的，相当于有13个偏移量，13是怎么来的，利用公式a+(i*n+j) *len，究竟怎么来的，后面再看看…a2这一行，有0,1,2,3，地址应该是a+13*2，这个就是答案么，a+26。i一般从0开始计，比如a[0]，存储地址就是a，因为这是第一个元素。
Python3天快速入门机器学习——Day01
weixin_62944327的博客
10-09 436
关键词：在某一个类别的文章中，出现的次数很多，但是在其他类别的文章当中出现很少。1）需要将user_id和aisle放在同一个表中 - 合并。2）找到user_id和aisle - 交叉表和透视表。文章A(100词) : 10次“经济” TF-IDF:0.2。文章B(100词) : 10次“非常” TF-IDF:0.1。1）pclass, sex 数据集当中类别特征比较多。相关系数 - 特征与特征之间的相关程度。2.3.2 字典特征提取 - 类别 -> one-hot编码。1、将数据集的特征-》字典类型。
408数据结构强化（自用）
最新发布
m0_70166478的博客
07-19 80
【代码】408数据结构强化（一) （本人自用）
数据结构之普利姆算法
weixin_45855469的博客
07-17 843
本文介绍了Prim算法的原理、实现思路和C语言代码实现。Prim算法用于生成图的最小生成树，采用贪心策略，每次选择与当前生成树相连的最小权值边。文章通过图示逐步演示了算法执行过程，并详细分析了代码实现的关键部分，包括lowcost和adjvex数组的作用。核心代码通过两层循环实现：外循环遍历所有节点，内循环寻找最小权值边。该算法时间复杂度为O(n^2)，适合稠密图的最小生成树求解。
Redis都有哪些数据结构，使用场景与原理解析
MarkerHub的博客
07-16 597
Redis GEO 底层使用 ZSet，score 是地理位置转为整数 score 的编码值。（key = 用户，field = 商品ID，value = 数量）是 Redis 自定义的字符串类型，支持动态扩容、安全、长度记录。不能存重复数据，若需要统计次数，用 Hash 或 ZSet 替代。本质是字符串，内部按位存储，1bit 表示一个状态。每条消息是一个有序条目（ID 唯一），支持消费确认。✅ String：字符串（最常用、最简单的类型）使用时建议一个用户一个 key，方便管理和清理。
【数据结构】单循环链表
2302_76793428的博客
07-17 922
摘要 单循环链表是一种尾节点指向头节点的特殊链表结构，形成闭合环。其节点结构与普通单链表相同，但尾节点指针指向头节点而非NULL。本文详细介绍了单循环链表的实现与操作，包括：初始化、插入（头插/尾插/按位置插入）、删除（头删/尾删/按位置/按值删除）、查找、清空、销毁等核心功能，并提供了各操作的图解和代码实现。文章还分析了单循环链表的应用场景（如约瑟夫问题、轮询调度等），优缺点（空间利用率高但操作较复杂），以及常见问题（如死循环预防、内存泄漏等）的解决方案。该数据结构适合需要环形访问的场景，但需特别注意循环
数据结构——单调栈
weixin_67028876的博客
07-18 655
单调栈是一种特殊的栈数据结构，它的特点是栈内的元素始终保持着某种单调性（递增或递减）。这种数据结构在解决一些数组相关的问题时非常高效，特别是涉及到 "下一个更大元素"、"上一个更小元素" 等场景。
春节特辑：图解密训练Day6 - 图的算法实践
邻接表则通过链表或数组来存储每个顶点的邻居，更适合表示稀疏图。 实现图的搜索算法主要有深度优先搜索（DFS）和广度优先搜索（BFS）。DFS通常使用递归或栈实现，先访问深度较深的节点；BFS则使用队列，按层次顺序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值