数据结构与算法—稀疏数组

已于 2023-01-07 12:14:15 修改
阅读量553 收藏
点赞数
分类专栏： 【数据结构与算法】 【Java】 文章标签： java 数据结构 稀疏数组
于 2023-01-07 12:11:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32015565/article/details/128561663
版权

稀疏数组

稀疏数组与二维数组

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

二维数组转成稀疏数组：
在这里插入图片描述
从图中可以看出：
稀疏数组的行、列、值的
（1）[0]行：二维数组 a（6*7）的行值，列值，以及元素值不为0的个数（8个）
（2）[1]行：二维数组的值 22 是第 a[0] 行，第 a[3] 列
（3）[2]行：二维数组的值 15 是第 a[0] 行，第 a[6] 列
（4）[3]行：二维数组的值 11 是第 a[1] 行，第 a[1] 列

从而知道：
稀疏数组的value 值，就是二维数组中不为0的元素值，一行一行，从上到下记
稀疏数组的行，列，就是对应value值在二维数组中的位置，比如22 在a[0][3]，11在a[1][1]，-6在a[2][3]。

稀疏数组和二维数组的转换

在这里插入图片描述
根据思路可以书写代码进行测试：

  1. 创建二维数组
public class Demo {

    public static void main(String[] args) {
        // 创建二维数组
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        array[3][4] = 2;
        // 遍历数组打印看看
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j] + " ");
            }
            System.out.println();
        }
    }
}

可以得到如下的数组：
在这里插入图片描述

  1. 将得到的二维数组转换成稀疏数组
class ArrayUtil {
	// 传入二维数组
    public void convert(int[][] a) {
        // 记录二维数组不为0的个数
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j] != 0) {
                    sum++;
                }
            }
        }

        // 根据sum创建稀疏数组，稀疏数组固定列为 3 列，包括row, col, val
        int[][] sparseArray = new int[sum + 1][3];
        // 行 row
        sparseArray[0][0] = a.length;
        // 列 col
        sparseArray[0][1] = a[0].length;
        // 值 val
        sparseArray[0][2] = sum;

        // 遍历二维数组，将不为 0 的值放入稀疏数组中
        // count 用于在稀疏数组中记录是第几个非 0 的数值
        int count = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                // 遍历稀疏数组并赋值
                if (a[i][j] != 0) {
                    count++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = a[i][j];
                }
            }
        }

        // 输出稀疏数组
        System.out.println("二维数组对应的稀疏数组：");
        for (int i = 0; i < sparseArray.length; i++) {
            System.out.printf("%d\t%d\t%d\t\n", sparseArray[i][0], sparseArray[i][1], sparseArray[i][2]);
        }
    }

}
  1. 完整代码
public class Demo {

    public static void main(String[] args) {
        // 创建二维数组
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        array[3][4] = 2;
        // 遍历数组打印看看
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
        new ArrayUtil().convert(array);
    }
}

class ArrayUtil {
	// 传入二维数组
    public void convert(int[][] a) {
        // 查询二维数组不为0的个数
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j] != 0) {
                    sum++;
                }
            }
        }

        // 根据sum创建稀疏数组，稀疏数组固定列为 3 列，包括row, col, val
        int[][] sparseArray = new int[sum + 1][3];
        // 行 row
        sparseArray[0][0] = a.length;
        // 列 col
        sparseArray[0][1] = a[0].length;
        // 值 val
        sparseArray[0][2] = sum;

        // 遍历二维数组，将不为0的值放入稀疏数组中
        // count 用于在稀疏数组中记录是第几个非 0 的数值
        int count = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                // 遍历稀疏数组并赋值
                if (a[i][j] != 0) {
                    count++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = a[i][j];
                }
            }
        }

        // 输出稀疏数组
        System.out.println("二维数组对应的稀疏数组：");
        for (int i = 0; i < sparseArray.length; i++) {
            System.out.printf("%d\t%d\t%d\t\n", sparseArray[i][0], sparseArray[i][1], sparseArray[i][2]);
        }
    }

}

打印：
在这里插入图片描述

  1. 将稀疏数组转二维数组
    在上面的基础上，在后面添加代码
		// 稀疏数组转成二维数组
        System.out.println("稀疏数组转成二维数组：");

        // 创建二维数组
        int[][] chessArr2 = new int[sparseArray[0][0]][sparseArray[0][1]];
        // 遍历稀疏数组非 0 值的行,并赋值
        for (int i = 1; i < sparseArray.length; i++) {
            // 将稀疏数组中0, 1列的值对应到二维数组下标；2列的值对应到所在下标的值
            chessArr2[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }

        // 遍历数组打印看看
        for (int i = 0; i < chessArr2.length; i++) {
            for (int j = 0; j < chessArr2[i].length; j++) {
                System.out.print(chessArr2[i][j] + " ");
            }
            System.out.println();
        }
  1. 完整代码：
public class Demo {

    public static void main(String[] args) {
        // 创建二维数组
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        array[3][4] = 2;
        // 遍历数组打印看看
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
        new ArrayUtil().convert(array);
    }
}

class ArrayUtil {

    public void convert(int[][] a) {
        // 查询二维数组不为0的个数
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j] != 0) {
                    sum++;
                }
            }
        }

        // 根据sum创建稀疏数组，稀疏数组固定列为 3 列，包括row, col, val
        int[][] sparseArray = new int[sum + 1][3];
        // 行 row
        sparseArray[0][0] = a.length;
        // 列 col
        sparseArray[0][1] = a[0].length;
        // 值 val
        sparseArray[0][2] = sum;

        // 遍历二维数组，将不为0的值放入稀疏数组中
        // count 用于在稀疏数组中记录是第几个非 0 的数值
        int count = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                // 遍历稀疏数组并赋值
                if (a[i][j] != 0) {
                    count++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = a[i][j];
                }
            }
        }

        // 输出稀疏数组
        System.out.println("二维数组对应的稀疏数组：");
        for (int i = 0; i < sparseArray.length; i++) {
            System.out.printf("%d\t%d\t%d\t\n", sparseArray[i][0], sparseArray[i][1], sparseArray[i][2]);
        }

        // 稀疏数组转成二维数组
        System.out.println("稀疏数组转成二维数组：");

        // 创建二维数组
        int[][] chessArr2 = new int[sparseArray[0][0]][sparseArray[0][1]];
        // 遍历稀疏数组非 0 值的行,并赋值
        for (int i = 1; i < sparseArray.length; i++) {
            // 将稀疏数组中0, 1列的值对应到二维数组下标；2列的值对应到所在下标的值
            chessArr2[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }

        // 遍历数组打印看看
        for (int i = 0; i < chessArr2.length; i++) {
            for (int j = 0; j < chessArr2[i].length; j++) {
                System.out.print(chessArr2[i][j] + " ");
            }
            System.out.println();
        }

    }


}

将稀疏数组写入磁盘（类五子棋游戏的保存）

到这，完成了稀疏数组和二维数组的转化。接下来，可以将稀疏数组 sparseArray 写入磁盘

		// 将稀疏数组写到磁盘中 map.data
        // 创建缓冲字符输出流
        BufferedWriter bw;
        try {
            bw = new BufferedWriter(new FileWriter("D:\\work\\workspace\\java-learn\\sparseArray\\map.data"));
            // 遍历稀疏数组，写入数据
            for (int i = 0; i < sparseArray.length; i++) {
                bw.write(sparseArray[i][0]+"\t"+sparseArray[i][1]+"\t"+sparseArray[i][2]+"\n");
            }
            // 写完后，将内存缓冲区的数据，刷新到文件中
            bw.flush();
            // 释放资源
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

上述代码执行后，会在相应目录下产生一个map.data文件，直接用txt打开，可以看到有4行3列的数据
在这里插入图片描述

从磁盘将数据取出

		// 从map.data中读取数据
        // 创建缓冲字符输入流
        System.out.println("------------------------------------");
        System.out.println("从文件中读出的稀疏数组：");
        BufferedReader br;
        List<String> list = new ArrayList<>();
        try {
            br = new BufferedReader(new FileReader("D:\\work\\workspace\\java-learn\\sparseArray\\map.data"));
            String line;
            while ((line = br.readLine()) != null) {
                // 可以将数据放入list或其他集合中，进行遍历还原出稀疏数组
                list.add(line);
            }
            // 释放资源
            br.close();

            // 创建稀疏数组
            int[][] sarr = new int[list.size()][3];
            // 遍历list数据
            for (int i = 0; i < list.size(); i++) {
                // 根据写入文件时的 \t 制表符分开放入数组中
                String[] s = list.get(i).trim().split("\t");
                sarr[i][0] = Integer.valueOf(s[0]);
                sarr[i][1] = Integer.valueOf(s[1]);
                sarr[i][2] = Integer.valueOf(s[2]);
            }
            // 遍历稀疏数组
            for (int i = 0; i < sarr.length; i++) {
                System.out.printf("%d\t%d\t%d\t\n", sarr[i][0], sarr[i][1], sarr[i][2]);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

可以看到打印出来的数据：
在这里插入图片描述

完整代码

package com.liwang.sparseArray;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

/**
 * @Author LiWang Chen
 * @Date 2023-01-06 13:26
 * @Version 1.0
 */
public class Demo {

    public static void main(String[] args) {
        // 创建二维数组
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        array[3][4] = 2;
        // 遍历数组打印看看
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
        new ArrayUtil().convert(array);
    }
}

class ArrayUtil {

    public void convert(int[][] a) {
        // 查询二维数组不为0的个数
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j] != 0) {
                    sum++;
                }
            }
        }

        // 根据sum创建稀疏数组，稀疏数组固定列为 3 列，包括row, col, val
        int[][] sparseArray = new int[sum + 1][3];
        // 行 row
        sparseArray[0][0] = a.length;
        // 列 col
        sparseArray[0][1] = a[0].length;
        // 值 val
        sparseArray[0][2] = sum;

        // 遍历二维数组，将不为0的值放入稀疏数组中
        // count 用于在稀疏数组中记录是第几个非 0 的数值
        int count = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                // 遍历稀疏数组并赋值
                if (a[i][j] != 0) {
                    count++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = a[i][j];
                }
            }
        }

        // 输出稀疏数组
        System.out.println("二维数组对应的稀疏数组：");
        for (int i = 0; i < sparseArray.length; i++) {
            System.out.printf("%d\t%d\t%d\t\n", sparseArray[i][0], sparseArray[i][1], sparseArray[i][2]);
        }

        // 将稀疏数组写到磁盘中 map.data
        // 创建缓冲字符输出流
        BufferedWriter bw;
        try {
            bw = new BufferedWriter(new FileWriter("D:\\work\\workspace\\java-learn\\sparseArray\\map.data"));
            // 遍历稀疏数组，写入数据
            for (int i = 0; i < sparseArray.length; i++) {
                bw.write(sparseArray[i][0]+"\t"+sparseArray[i][1]+"\t"+sparseArray[i][2]+"\n");
            }
            // 写完后，将内存缓冲区的数据，刷新到文件中
            bw.flush();
            // 释放资源
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }


        // 从map.data中读取数据
        // 创建缓冲字符输入流
        System.out.println("------------------------------------");
        System.out.println("从文件中读出的稀疏数组：");
        BufferedReader br;
        List<String> list = new ArrayList<>();
        try {
            br = new BufferedReader(new FileReader("D:\\work\\workspace\\java-learn\\sparseArray\\map.data"));
            String line;
            while ((line = br.readLine()) != null) {
                // 可以将数据放入list或其他集合中，进行遍历还原出稀疏数组
                list.add(line);
            }
            // 释放资源
            br.close();

            // 创建稀疏数组
            int[][] sarr = new int[list.size()][3];
            // 遍历list数据
            for (int i = 0; i < list.size(); i++) {
                // 根据写入文件时的 \t 制表符分开放入数组中
                String[] s = list.get(i).trim().split("\t");
                sarr[i][0] = Integer.valueOf(s[0]);
                sarr[i][1] = Integer.valueOf(s[1]);
                sarr[i][2] = Integer.valueOf(s[2]);
            }
            // 遍历稀疏数组
            for (int i = 0; i < sarr.length; i++) {
                System.out.printf("%d\t%d\t%d\t\n", sarr[i][0], sarr[i][1], sarr[i][2]);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }


        // 稀疏数组转成二维数组
        System.out.println("------------------------------------");
        System.out.println("稀疏数组转成二维数组：");

        // 创建二维数组
        int[][] chessArr2 = new int[sparseArray[0][0]][sparseArray[0][1]];
        // 遍历稀疏数组非 0 值的行,并赋值
        for (int i = 1; i < sparseArray.length; i++) {
            // 将稀疏数组中0, 1列的值对应到二维数组下标；2列的值对应到所在下标的值
            chessArr2[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }

        // 遍历数组打印看看
        for (int i = 0; i < chessArr2.length; i++) {
            for (int j = 0; j < chessArr2[i].length; j++) {
                System.out.print(chessArr2[i][j] + " ");
            }
            System.out.println();
        }

    }


}

在这里插入图片描述
在这里插入图片描述
可以看看我的个人博客：
网站：https://www.fuzm.wang / https://liwangc.gitee.io
—————————————————————————
作为初学者，很多知识都没有掌握，见谅，如有错误请指出，以期进步，感谢！。后续有新的学习，继续补充上来。

liwangC
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java数据结构与算法】稀疏数组
01-20
文章目录数据结构类型线性结构与非线性结构稀疏数组实例应用二维数组转稀疏数组的思路稀疏数组转原始的二维数组思路 数据结构类型 数据结构包括：线性结构和非线性结构。 线性结构与非线性结构 线性结构 线性结构...
数据结构与算法 稀疏数组
10-15 133
稀疏数组和二维数组互相转换的思路分析 代码实现：
二、数据结构与算法 稀疏数组
sunweihao2019的博客
02-14 1218
1.稀疏算法的目的就是储存的时候，不用储存那么多，节省空间（时间换空间）。 稀疏数组：就是无效值（可以是规定值吧，相同的比较多）比较多，很稀疏，其实就是把原来的数组（这个数组有多个相同的值，这里是0，因为默认值为0，无值的情况默认0，不用设置值，而其他的值要设置值），通过规律来创建一个新的数组（值较少，且可以按一定规律还原为原数组），然后储存起来，然后。 思路如下： 原数组–》稀疏数组–》储存–》拿出来–》还原–》使用。 其中下面的表示原数组 下面的表示稀疏数组 代码（储存省略）： public cl
JAVA数据结构与算法-稀疏数组
h123456789999999的博客
01-18 186
稀疏数组的基本介绍 当一个数组中大部分的元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组 稀疏数组的处理方法是： 记录数组一共有几行几列，有多少个不同的值 把具有不同值的元素行列及值记录在一个小规模的数组中，从而缩小程序的规模 稀疏数组举例说明类似下图这样的数组 稀疏数组的应用实例 1.使用稀疏数组，来保留类似前面的二维数组（类似棋盘，地图等等） 2.把稀疏数组存盘，并且可以重新恢复原来的二维数组数 3 项目的整体思路分析 二维数组转稀疏数组思路 1 遍历原始的二维数组，得到有效数据的
数据结构简介（稀疏数组）
sunshixuan6666的博客
08-10 937
java数组，稀疏数组，数据结构
JAVA数据结构与算法之稀疏数组
weixin_43905191的博客
02-14 709
数据结构之稀疏数据的定义以及java语言描述
数据结构和算法----稀疏数组.rar
09-17
学习笔记[韩顺平老师讲的数据结构和算法]；数据结构和算法之稀疏数组。个人的一个理解。
数据结构与算法，Java语言描述
11-30
有对数据结构与算法的基本概念、线性表、栈与队列、串、数组与矩阵、树与二叉树、图的一些逻辑结构的介绍，以及如何用Java语言实现其各种各样的存储结构的代码，同时也会有一些相关的应用，比如后缀表达式求值、字符...
数据结构与算法-C#版
03-09
这是C#版的数据结构与算法的代码实现，包括：顺序表，单链表，双链表；顺序栈，链栈；顺序队列，链队列；顺序串；用数组进行特殊矩阵的存储，稀疏矩阵的存储；顺序存储二叉树，链式存储二叉树，哈夫曼树；多重链表...
SpringBoot+Websocket两种实现方式
qq_32015565的博客
05-21 1733
SpringBoot+Websocket两种实现方式 在学习使用中，记录此文，避免踩坑，如有不好见谅。 1、引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> 2、yml spring: .
SpringBoot文件上传、下载超限制记录
qq_32015565的博客
02-20 1267
记录在 SpringBoot上传、下载文件中遇到的情况。项目以springboot+vue开发，在vue中未设置文件上传下载的限制，所以此次记录的均是springboot侧内容。 上传 报错： org.springframework.web.multipart.MaxUploadSizeExceededException: Maximum upload size exceeded; nested exception is java.lang.IllegalStateException: org.apach
Java——Stream流的学习
最新发布
qq_32015565的博客
02-19 970
java stream的学习使用
Java-流和IO
qq_32015565的博客
01-19 963
记录下java流和常用的基本操作
java8Stream
qq_32015565的博客
07-28 943
java8 stream的使用
vue-admin-template学习（四）
qq_32015565的博客
02-25 927
vue-admin-template角色的权限判断 后端 实现获取用户角色的方法挺多的，比如： 可以单独写一个通过用户标识获取用户的roles接口 可以在用户登录成功后，返回用户的信息中加入用户的roles信息，我的项目目前用的是这个，所以会以这个写一下记录 实现： // 设置角色 Set<String> rolesSet = roleService.getUserRolesSet(user.getUsername()); return Result.success(MapUtil
数据结构与算法—队列
qq_32015565的博客
02-18 610
队列学习与使用
Windows10专业版 安装docker
qq_32015565的博客
07-14 566
1、win10专业版系统支持docker的安装，需要开启 Hyper-V。 （1）开启 在电脑左下角win图标上右键选择第一个“应用和功能” 点击“程序和功能” 点击“启用或关闭Windows功能” 找到Hyper-V选择开启，确认即可。 2、安装docker docker 官方下载地址：https://docs.docker.com/do...
Java—时间API的使用
qq_32015565的博客
04-14 408
文章目录时间API获取时间戳获取当前时间 有时间在使用时间上还懵懵的，记录一下，让自己更清楚。 时间API 获取时间戳 System.currentTimeMillis() public static void main(String[] args) { long currentTimeMillis = System.currentTimeMillis(); System.out.println("当前时间戳 = " + currentTimeMillis); } // 输出结果：当前时间戳
java数据结构与算法笔记
07-25
\[2\]\[3\]在这个笔记中，你可以学习到如何使用稀疏数组来处理特定的数据结构问题，以及如何分析算法的时间复杂度和空间复杂度。这些知识对于理解和设计高效的算法非常重要。 #### 引用[.reference_title] - *1* *2*...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值