稀疏数组与二维数组的转化

从零到一:RT-ThreadW5500的硬件抽象层设计哲学实践启示 本文深入探讨了RT-Thread操作系统下W5500以太网模块的硬件抽象层(HAL)设计哲学实践。通过GD32F103和STM32F103平台的适配案例,详细阐述了如何利用RT-Thread的驱动框架实现跨平台硬件无关性、模块化设计及配置定制,为嵌入式开发者提供了可复用的HAL设计方法论和实战经验。 阅读详情

稀疏数组:

 一般使用在存在大量相同数据的表格中,存储了许多没有意义的数据。举个例子:一个数组存储了1000个数据,有效数据仅仅只有几个,就可以使用稀疏数组存储。

要求:

1.假设有一个11*11的棋盘,1代表白子,2代表黑子
2.目前棋盘上有三个棋子,分别位于二位数组的[1][2]白子、[2][3]白子、[3][4]黑子
3.创建对应的二维数组,并将其转化为稀疏数组存入map.data文件中

实现:

package sparsearr;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/*
* 二维数组与稀疏数组的转化
* */
public class SparseArray {
    public static void main(String[] args) throws IOException {
        /*
        1.假设有一个11*11的棋盘,1代表白子,2代表黑子
        2.目前棋盘上有三个棋子,分别位于二位数组的[1][2]白子、[2][3]白子、[3][4]黑子
        3.创建对应的二维数组,并将其转化为稀疏数组存入map.data文件中
        */

        //创建对应的二位数组
        int[][] chessArr = new int[11][11];
        //存入数据
        chessArr[1][2] = 1;
        chessArr[2][3] = 1;
        chessArr[3][4] = 2;
        //遍历数组,获取其中有效数据的条数并记录
        int sum = 0;
        System.out.println("原始数组:");
        for (int i =0;i<chessArr.length;i++) {
            for (int j = 0; j < chessArr[i].length; j++) {
                System.out.printf("%d\t", chessArr[i][j]);
                if (chessArr[i][j] != 0)
                    sum++;
            }
            System.out.println();
        }
        System.out.println("原始数组中的有效数据条数为:"+sum);

        System.out.println("------------------------------------");
        //将二维数组转换为稀疏数组
        //创建稀疏数组,行数=有效数据+1;列数=3
        int[][] sparseArray = new int[sum+1][3];
        sparseArray[0][0] = 11;
        sparseArray[0][1] = 11;
        sparseArray[0][2] = sum;
        //定义行变量
        int count = 0;
        for (int i = 0;i<chessArr.length;i++) {
            for (int j = 0; j < chessArr[i].length; j++) {
                if (chessArr[i][j] != 0){
                    count++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = chessArr[i][j];
                }
            }
        }

        //输出稀疏数组,并将稀疏数组存入map.data
        BufferedWriter bw = new BufferedWriter(new FileWriter("map.data"));
        System.out.println("稀疏数组:");
        for(int[] sparse : sparseArray){
            for(int data : sparse){
                bw.write(data+" ");
                System.out.printf("%d\t",data);
            }
            bw.newLine();
            System.out.println();
        }
        //关闭资源
        bw.close();
    }
}

结果:

 

map.data :

 要求:

1.读取上述map.data文件,将其存入稀疏数组
2.将稀疏数组转化为二维数组并输出

实现:

package sparsearr;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class SparseArray2 {
    public static void main(String[] args) throws IOException {
        /*
        * 1.读取上述map.data文件,将其存入稀疏数组
        * 2.将稀疏数组转化为二维数组并输出
        * */
        BufferedReader br = new BufferedReader(new FileReader("map.data"));
        //定义稀疏数组
        int[][] sparseArray = new int[4][3];
        String str;
        int count = 0;
        //获取数据
        while((str=br.readLine())!=null){
            //将每行数据拆分为单个数据
            String[] s = str.split(" ");
            for(int i = 0;i<s.length;i++){
                sparseArray[count][i] = Integer.parseInt(s[i]);
            }
            count++;
        }
        //遍历稀疏数组
        System.out.println("稀疏数组:");
        for(int[] arr : sparseArray){
            for(int data : arr){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        System.out.println("-----------------------------");
        //将稀疏数组转化为二维数组
        int[][] chessArray = new int[sparseArray[0][0]][sparseArray[0][1]];
        //遍历稀疏数组,将数据添加到二维数组
        for(int i = 1;i<sparseArray.length;i++){
            chessArray[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        //遍历二维数组
        System.out.println("恢复后的二维数组:");
        for(int[] arr : chessArray){
            for(int data : arr){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        br.close();
    }
}

结果:

 

多时间尺度源储荷微电网协调调度+日前日内实时+需求响应——附代码 为提高区域电网新能源消纳率,使电力系统运行成本最小,提高电力系统供电可靠性。提出考虑特性分布的储能电站接入的电网多时间尺度“源–储–荷”协调调度策略。综合储能电站、负荷侧各类需求响应资源的多时间尺度特性制定日前调度计划,并通过日内滚动实时修正实现对预测数据更高精度的保证。以系统运行成本、弃风惩罚成本、失负荷惩罚成本为目标函数,建立多时间尺度调度模型。最后通过 MATLAB 平台调用商用软件包 CPLEX 完成混合整数规划优化,结果表明该调度策略可以达到系统运行成本最优,降低弃风率的效果。 阅读详情

相关推荐

中级软考(软件攻城狮)第3章知识点——数据结构数据运算(线性结构+非线性结构)

本文系统梳理了数据结构中的线性非线性结构。线性部分详细介绍了线性表(顺序/链式存储及时间复杂度对比)、栈(后进先出特性及应用)、队列(循环队列双端队列)以及串(空串子串概念)。非线性部分涵盖数组、矩阵、广义表,重点解析了树结构(二叉树性质、存储方式及遍历方法),并深入讲解了最优二叉树(哈夫曼树)的构建原理编码应用。全文通过图示对比和实例说明,清晰呈现了各类数据结构的特点、存储方式及典型应用场景。

睡不醒的每天 163

数据结构算法——Java实现二维数组稀疏数组相互转化

数据结构算法——Java实现二维数组稀疏数组相互转化 在实际工作中,为了节约存储空间,如果数组元素有较多相同元素时,我们可以通过将其转化稀疏数组进行存储。 以下是一个二维数组稀疏数组的简单Java代码: package sparsearray; public class SparseArray { public static void main(String[] args) ...

YueYingGuang的博客 297

sortable.js(jquery.fn.sortable、jquery.fn.sortable.min.js)最新版

最新拖拽排序插件,及简单DEMO

二维数组稀疏数组之间的转化

/* * 1.稀疏数组介绍: * 如果原数组的非0元素的个数有n个,则稀疏数组有n+1行,列数不变,一共有三列 * 第一行保存的数据: 原始数组的行 原始数组保存的列 原始数组中非0的元素个数 * 第二行保存的数据: 第一个非0元素所在的行 第一个非0元素所在的列 第一个非0元素的值 * .......... * * 2.二维数组转化稀疏数组: * 遍历二维数组,求出原始二维数组中非0元素的个数sum * 创建稀疏数组a[sum+1][3] * 将原始二维数组的非0元素的值存

CodePanda@GPF的博客 221

稀疏数组二维数组相互转化

图示 二维数组稀疏数组的思路 遍历 原始的二维数组,得到有效数据的个数 sum 根据sum 就可以创建 稀疏数组 sparseArr int[sum + 1] [3] 将二维数组的有效数据数据存入到 稀疏数组 稀疏数组转原始的二维数组的思路 先读取稀疏数组的第一行,根据第一行的数据,创建原始的二维数组,比如上面的 chessArr2 = int [11] [11] 在读取稀疏数组后几行的数据,并赋给 原始的二维数组 即可. ...

Frank---7的博客 7388

Java数据结构算法二维数组稀疏数组转化

二维数组稀疏数组的转换

lolly1023的博客 1517

二维数组稀疏数组的相互转化

package com.haoran.array; public class Demo08 { //写一个展示普通二维数组 并转换为稀疏数组 并可以翻转 public static void main(String[] args) { int [][] array0=new int[5][5]; array0[0][1]=1; array0[1][2]=2; array0[4][4]=5; arrayprin.

qq_45326705的博客 222

二维数组稀疏数组的相互转化

稀疏数组简介一.将二维数组转化稀疏数组二.将稀疏数组转化为原二维数组 简介 当一个二维数组大部分是0,或者为同一个值的数组时(即有效数据远小于无效数据时),可以用稀疏数组。 具体格式如下 下标 行 列 具体数值 0 原数组的行数 原数组的列数 原数组的有效值的个数sum 1 第1个有效数据在原数组中的所在行 第1个有效数据在原数组中的所在列 第1个有效值 2 第2个有效数据在原数组中的所在行 第2个有效数据在原数组中的所在列 第2个有效值 …… …… …… …… 共有sum

yydskh_的博客 266

稀疏数组二维数组转化,将稀疏数组存入磁盘

算法学习之稀疏数组

weixin_52364868的博客 419

002稀疏数组二维数组的互相转化

稀疏sparsearray数组 稀疏数组应用场景: 当数组中记录了很多没有意义的数据—>稀疏数组数组中大部分数据为0或相同的值时,可以用稀疏数组来保存 处理方法: 1.记录数组的行列,多少个不同的值 2.把不同值的行列及值记录在一个小规模数组里 二维–>稀疏思路: 1.遍历原始的二维数组,得到有效数据个数sum 2.根据sum创建稀疏数组sparseArr int[sum+1】[3] 3.将二维数组的有效数据存入稀疏数组 //代码实现 /* * 实现数组的压缩和解压 */ publi

qq_43622031的博客 175

稀疏数组二维数组转化思路

当一个数组中大部分元素为0,或者为同一值的数组时,可以使用稀疏数组来保存该数组。把具有不同值的元素和行列及值记录在一个小规模的数组中,从而缩小程序的规模。稀疏数组在棋盘中棋子位置的存储中将二维数组转变成稀疏数组达到减小存储的目的。记录数组一共有几行几列,有多少个不同值。

qq_74845484的博客 156

快速学会数据结构中的链式队列循环队列

一种允许从一端插入数据,另外一端删除数据的线性存储结构称为队列。把数据插入的这端称为队列的队尾, 数据删除这端称为队列的队头。插入操作称为入队;删除操作称为出队。先进先出、后进后出数据缓存。

2401_82745609的博客 541

GXF 3.2.0 to 4.0 CUDA 12 路径 API 数据结构增量分析

分析范围:以仓库中分支对比为基础,聚焦)可用的公共 API 数据结构变化。由于 GXF 核心头文件在各 CUDA 版本间共享,下列新增/修改的接口在 CUDA 12 构建上同样生效。对比链接:https://github.com/NVIDIA-ISAAC-ROS/isaac_ros_nitros/compare/release-3.2…release-4.0。

eloudy的专栏 253

数据结构】图的应用:最小生成树(Prim / Kruskal)

摘要:最小生成树(MST)是带权连通无向图中边权总和最小的生成树,常用于网络优化问题。Prim算法从顶点出发,逐步选择连接已选和未选顶点集的最小边,适合稠密图(时间复杂度O(n²))。Kruskal算法按边权排序后依次选择不构成环的边,适合稀疏图(时间复杂度O(e log e))。两者均基于贪心策略,但Prim侧重顶点扩张,Kruskal侧重边合并。关键区别在于数据结构(Prim用优先队列,Kruskal用并查集)和适用场景。典型例题需掌握选边过程,记忆口诀为“稠密Prim,稀疏Kruskal”。软考中常考

bianyuan172的博客 347

数据结构 --- 二叉树&哈希表

本篇数据结构学习笔记分为二叉树、哈希表两大板块。二叉树部分讲解树形基础概念、链式存储方式、前 / 中 / 后序遍历算法,介绍带占位符字符串递归创建二叉树的方法,配套结点计数、深度计算、内存销毁等递归代码实现,补充二叉树核心数学性质。哈希表板块梳理哈希函数、哈希冲突概念,对比开放定址法、链地址法两种冲突解决方案,分析操作的时间复杂度。最后完整给出拉链哈希表五大功能模块的 C 语言实现代码,讲解插入、查找、打印、销毁的执行流程,同时点明现有代码的缺陷优化方向。

2401_86288082的博客 717

数据结构】C语言实现链式二叉树

本文系统介绍了链式二叉树的实现操作,包括节点创建、遍历算法(先序、中序、后序、层序)、节点统计(总数、叶子节点、左右子节点)、高度计算、层级节点查询、节点查找、完全二叉树判断、二叉树翻转和销毁等16个核心功能。重点阐述了递归思想在二叉树操作中的应用,并展示了队列在层序遍历和完全二叉树判断中的关键作用。所有操作均通过C语言实现,提供了完整的代码示例,为理解和实现链式二叉树数据结构提供了全面参考。

Jupiter1007的博客 334

嵌入式C语言常见考察点(2)

本文介绍了循环队列实现、 冒泡排序优化、二分查找、 位运算应用、volatile关键字重要性、大小端判断等

2301_79475128的博客 171

第 4 章 数据结构总览:SDMA 在驱动里的实体

本章将硬件概念映射到SDMA驱动的C数据结构,主要包含三层嵌套关系:芯片级amdgpu_sdma管理所有SDMA实例,实例级amdgpu_sdma_instance对应物理引擎(含GFX和Page两条队列),队列级amdgpu_ring处理具体命令。关键字段包括固件管理、队列状态、中断源、硬件差异抽象(函数指针)等,完整反映了"多实例→双队列"的硬件模型。通过这种层级化设计,驱动实现了对SDMA引擎的精细化控制。

图形/计算GPU的驱动与虚拟化技术分享园地 365

数据结构】哈希表:构造冲突处理

文章摘要: 哈希表是一种通过哈希函数直接定位数据的查找结构,核心在于设计哈希函数(如除留余数法)和处理冲突(开放地址法/链地址法)。重点包括:1)除留余数法中质数p的选择;2)线性探测易产生堆积,链地址法效率更稳;3)装填因子α影响查找效率;4)ASL计算(成功/失败)是软考高频考点,需掌握比较次数统计。典型例题展示ASL计算流程,口诀帮助记忆要点。建议重点掌握冲突处理和ASL计算,以应对软考选择应用题。

bianyuan172的博客 245

数据结构:二叉树

树:由根节点和若干个子节点构成的具有一对多关系的数据的集合,称为树形结构。完全二叉树:在满二叉树基础上,按照从左到右,从上到下依次增加节点的树形结构。二叉树:树的广度为2的树形结构,且各节点的左右子节点不能交换。满二叉树:在不增加层数的情况下,无法再增加一个节点。树的度(数的广度):树中节点最大的度是该数的广度。K层满二叉树:第K层的节点个数:2^(K-1)叶子节点(终端节点):向后没有子节点的节点。分支节点(非终端节点):有子节点的节点。节点的度:节点的子节点个数。叶子节点的节点的度为0。

yxg0505的博客 513

数据结构】图的遍历:广度优先搜索(BFS)

摘要: 广度优先搜索(BFS)是一种基于队列实现的图遍历算法,核心思想是“层层推进”,先访问起点邻接顶点,再逐层扩展。DFS的纵向深入不同,BFS横向扩展,适合求解无权图最短路径。算法关键点包括:入队时立即标记已访问,避免重复入队;时间复杂度邻接表为O(n+e),邻接矩阵为O(n²)。BFS生成树具有“矮胖”特性,根到任意顶点的路径为最短路径。典型应用包括连通性判断、二分图检测等。需重点掌握队列实现逻辑及DFS的对比(如数据结构、遍历顺序等)。软考常考BFS序列模拟及陷阱(如访问标记时机)。

bianyuan172的博客 271
上一篇: Java判断用户输入数字的位数
下一篇: 使用数组模拟队列
ice_YJY
博客等级 码龄5年 0粉丝 · 6原创
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值