内功之--稀疏数组

最新推荐文章于 2022-02-08 18:27:10 发布
最新推荐文章于 2022-02-08 18:27:10 发布
阅读量197 收藏
点赞数
分类专栏： java 文章标签： 数据结构 稀疏数组 内功
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuruizai110/article/details/104139875
版权

线性结构

  1. 数据元素之间存在一对一的线性关系。
  2. 存储结构。顺序存储（数组）和链式存储（链表） 。顺序存储的线性表称为顺序表，顺序表中的元素是连续的。
  3. 链表中的元素不一定是连续的。
  4. 常见的线性结构：数组，对列，链表和栈。

非线性结构

       树，图

一.什么是稀疏数组？

      当一个数组中大部分元素为0，或者为同一个值时，可以用稀疏数组来保存该数组。

    稀疏数组处理方法：

  • 记录数组一共有几列几行，有多少个不同值。
  • 把不同值所在行和列及其值记录在一个小规模的数组里。

 

二.实例及代码实现

        二维数组转换为稀疏数组。

        稀疏数组转换为二维数组。

 

 

/** 
 * Project Name:leetcode 
 * File Name:SpareArray.java 
 * Package Name:SpareArray 
 * Date:2020年2月1日下午10:34:44 
 * Copyright (c) 2020, chenzhou1025@126.com All Rights Reserved. 
 * 
*/

package SpareArray;

/**
 * ClassName:SpareArray <br/>
 * Function: TODO ADD FUNCTION. <br/>
 * Reason: TODO ADD REASON. <br/>
 * Date: 2020年2月1日 下午10:34:44 <br/>
 * 
 * @author yrz
 * @version
 * @since JDK 1.6
 * @see
 */
public class SpareArray {

	public static void main(String[] args) {
		// 创建原始二维数组 11*11
		// 0:表示没有棋子，1表示 黑子，2表示 蓝子

		int chessArr[][] = new int[11][11];
		chessArr[1][2] = 1;
		chessArr[2][3] = 2;

		// 输出二维数组
		System.out.println("原始数组-------------");
		for (int[] chess : chessArr) {
			for (int arr : chess) {
				System.out.printf("%d\t", arr);
			}
			System.out.println();
		}

		// 将原始数组转换为稀疏数组

		// 1. 遍历 原始的二维数组，得到有效数据的个数 sum

		int sum = 0;
		for (int i = 0; i < chessArr.length; i++) {
			for (int j = 0; j < chessArr.length; j++) {
				if (chessArr[i][j] != 0) {
					sum++;
				}
			}
		}
		// 2. 根据sum 就可以创建 稀疏数组 sparseArr int[sum + 1] [3]

		int sparseArr[][] = new int[sum + 1][3];
		sparseArr[0][0] = 11;
		sparseArr[0][1] = 11;
		sparseArr[0][2] = sum;
		// 3. 将二维数组的有效数据数据存入到 稀疏数组
		int count = 0;
		for (int i = 0; i < chessArr.length; i++) {
			for (int j = 0; j < chessArr.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();
		System.out.println("输出稀疏数组");
		for (int[] sparse : sparseArr) {
			for (int data : sparse) {
				System.out.printf("%d\t", data);
			}
			System.out.println();
		}

		// 稀疏数组转原始的二维数组的思路

		// 1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的 chessArr2 = int [11][11]
		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[] chess : chessArr2) {
			for (int data : chess) {
				System.out.printf("%d\t", data);
			}
			System.out.println();
		}
	}
	

	
}

输出结果：

原始数组-------------
0    0    0    0    0    0    0    0    0    0    0    
0    0    1    0    0    0    0    0    0    0    0    
0    0    0    2    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    

输出稀疏数组
11    11    2    
1    2    1    
2    3    2    

还原后的原始数组
0    0    0    0    0    0    0    0    0    0    0    
0    0    1    0    0    0    0    0    0    0    0    
0    0    0    2    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
 

改造代码：

  • 保证函数只做一件事
  • 命名规范
/** 
 * Project Name:leetcode 
 * File Name:SpareArray.java 
 * Package Name:SpareArray 
 * Date:2020年2月1日下午10:34:44 
 * Copyright (c) 2020, chenzhou1025@126.com All Rights Reserved. 
 * 
*/

package SpareArray;

/**
 * ClassName:SpareArray <br/>
 * Function: TODO ADD FUNCTION. <br/>
 * Reason: TODO ADD REASON. <br/>
 * Date: 2020年2月1日 下午10:34:44 <br/>
 * 
 * @author yrz
 * @version
 * @since JDK 1.6
 * @see
 */
public class SpareArray2 {

	public static void main(String[] args) {
		// 创建原始二维数组 11*11
		// 0:表示没有棋子，1表示 黑子，2表示 蓝子

		int chessArr[][] = new int[11][11];
		chessArr[1][2] = 1;
		chessArr[2][3] = 2;

		// 输出二维数组
		System.out.println("原始数组-------------");
		for (int[] chess : chessArr) {
			for (int arr : chess) {
				System.out.printf("%d\t", arr);
			}
			System.out.println();
		}

		// 将原始数组转换为稀疏数组

		int sparseArr[][] = convertOriginalArrayToSparseArray(chessArr);

		// 稀疏数组转原始的二维数组的思路
		convertSparseArrayToOriginalArray(sparseArr);

	}

	// 改造代码
	private static int[][] convertOriginalArrayToSparseArray(int chessArr[][]) {
		// 1. 遍历 原始的二维数组，得到有效数据的个数 sum

		int sum = 0;
		for (int i = 0; i < chessArr.length; i++) {
			for (int j = 0; j < chessArr.length; j++) {
				if (chessArr[i][j] != 0) {
					sum++;
				}
			}
		}
		// 2. 根据sum 就可以创建 稀疏数组 sparseArr int[sum + 1] [3]

		int sparseArr[][] = new int[sum + 1][3];
		sparseArr[0][0] = 11;
		sparseArr[0][1] = 11;
		sparseArr[0][2] = sum;
		// 3. 将二维数组的有效数据数据存入到 稀疏数组
		int count = 0;
		for (int i = 0; i < chessArr.length; i++) {
			for (int j = 0; j < chessArr.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();
		System.out.println("输出稀疏数组");
		for (int[] sparse : sparseArr) {
			for (int data : sparse) {
				System.out.printf("%d\t", data);
			}
			System.out.println();
		}

		return sparseArr;
	}

	private static void convertSparseArrayToOriginalArray(int[][] sparseArr) {
		// TODO Auto-generated method stub
		// 1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的 chessArr2 = int [11][11]
		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[] chess : chessArr2) {
			for (int data : chess) {
				System.out.printf("%d\t", data);
			}
			System.out.println();
		}

	}

}

 

yuruizai110
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
稀疏数组学习总结和C++实现代码
jean7155的专栏
12-01 695
1、稀疏数组是什么？ 稀疏数组的应用场景是：当普通数组中无效数据量远远大于有效数据量时，可以用稀疏数组对数组进行压缩。 是的，稀疏数组的功能就是进行压缩。节省内存占用，或者节约硬盘占有，网络传输等。 2、实例说明 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 2...
编程内功心法-编程算法题库
最新发布
07-14
- **最接近的三数之和**：该题的目标是在一个数组中找到三个数，使得它们的和与目标值最接近。常用的解法是先对数组进行排序，然后使用双指针技术逐个枚举数组中的元素，寻找最佳解。 - **移除元素**：此题要求从一...
【C++】稀疏数组
taoxing
07-09 855
一.基本介绍 稀疏就是“少”的意思嘛，数组我们也知道就是一种基础的顺序存储结构。对于数组来说，一般无用的位置都标0，有实际意义的地方给出具体的值，所以当空闲的位置（标0）很多时我们就认为它很稀疏。 如下图所示，我们后面的例子也以此二维数组为例： 这样就对数组的空间造成了极大的浪费，所以我们引出了稀疏数组来节约空间，我们只记录数组中有效的数据，稀疏数组的结构如下： 数组下标 行（row） 列（col） 值（value） 0 5 7 7 1 0 5 1 2 1 0 2 3 1
棋盘中可能用到的稀疏数组 C++ 实现
qq_38777021的博客
08-29 178
#include <iostream> using namespace std; #define info __FILE__ << " " << __func__ << " "<< __LINE__ << " " template<typename T> int getRows(const T & array) { return sizeof(array) / sizeof(array[
稀疏数组
孔祥月的博客
07-03 713
稀疏数组 引入 题意：编写一个五子棋程序，有存盘退出和续上盘的功能。棋盘是11×11格局。 思路：使用二维数组记录棋盘,默认数组为0,1代表黑色棋子。2代表蓝色棋子。 思路问题：因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据，可以用稀疏数组进行压缩。 稀疏数组 介绍：当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。 ...
稀疏数组（Sparsearray）
jefferyfg的博客
09-24 594
我们在了解稀疏数组之前先来看一个实际的需求 上图中要记录棋盘的数据，可以用二维数组来记录，但是有很多没有意义的数据，所以可以使用稀疏数组来记录 处理方法： 1.记录二维数组一共有几行几列，有多少个不同的值 2.把具有不值得元素行列及值记录在一个小规模的数组中，从而缩小程序的规模 编程思路 将二维数组转化为稀疏数组 1. 遍历原始二维数组，获取有效数据的个数num for (int i=0;i...
笑谈企业内功--余明阳在南京演讲.doc
09-26
【企业定位与发展战略】 在市场竞争日益激烈的环境下，企业必须明确自身的定位和发展策略。如同南京曾经试图成为“南京都市圈”的中心，但面对...这些因素共同构成了企业成功的“内功”，助力企业在竞争中脱颖而出。
程序员内功修炼-V1.0和面试思维导图.zip
01-22
《程序员内功修炼-V1.0》是一本旨在提升程序员技术实力和面试技巧的资源集合。这份资料包包含了两个核心部分：《程序员内功修炼-V1.0》PDF文档和一个思维导图，两者都是为了帮助程序员在求职过程中增强竞争力。 PDF...
程序员内功修炼-V1.0.pdf
04-05
文档中可能详细介绍了数组、链表、栈、队列、树（二叉树、堆、AVL树、红黑树等）、图、散列表等基本数据结构，以及排序（冒泡排序、选择排序、插入排序、快速排序、归并排序等）、查找（线性查找、二分查找、哈希...
程序员内功修炼 - 数据结构(C#)
06-12
你有没有面试的时候，被问到数据结构的问题，你有没有在面对需求的时候一头雾水？五斗米老师又出新课程了，数据结构一直是程序员的软实力，是算法课题的基础，游戏行业对其更为看重。学习C#语言之后的能力进阶，写出...
稀疏矩阵和多维数组的实现
06-30
　　　1、熟悉三元组方式存储稀疏矩阵的原理和算法； 2、掌握多维数组的存储空间分配和访问算法。 　　　
力扣-面试题10.05 稀疏数组搜索（C++）- 二分变形
qq_40467670的博客
02-08 522
题目链接：https://leetcode-cn.com/problems/sparse-array-search-lcci/ 题目如下： class Solution { public: int findString(vector<string>& words, string s) { int low=0,high=words.size()-1; while(low<=high){ int mid=low+(hig
数据结构教程—稀疏数组的三元表示及常用相关函数C++类实现
weixin_45189666的博客
06-06 345
头文件即类定义： #include <iostream> #define MaxSize 20 using namespace std; class Triple { private: int row;//保存原矩阵行数 int col;//保存原矩阵列数 int nums; int data[MaxSize][3];// public: void CreatMat(int a[6][7], int M, int N);//以a矩阵创建三元组
稀疏数组和队列
闵浮龙的博客
06-21 223
一、稀疏 sparsearray 数组 1、先看一个实际的需求 编写的五子棋程序中，有存盘退出和续上盘的功能。 分析问题: 因为该二维数组的很多值是默认值 0, 因此记录了很多没有意义的数据.->稀疏数组。 2、基本介绍 当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。 稀疏数组的处理方法是: 记录数组一共有几行几列，有多少个不同的值 把具有不同...
程序员内功修炼：基础篇-V1.0
在数据结构与算法方面，文档可能详细讲解了数组、链表、栈、队列、树、图等基本数据结构，以及排序、搜索、图算法等核心算法。这些知识是程序员解决复杂问题的基础，通过学习可以提高编程效率和代码质量。例如，排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值