今天和你聊聊稀疏数组！

最新推荐文章于 2022-06-04 13:33:31 发布
最新推荐文章于 2022-06-04 13:33:31 发布
阅读量130 收藏
点赞数
文章标签： java 经验分享 程序人生
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51276056/article/details/114199283
版权

今天和你聊聊稀疏数组！

前言1：稀疏数组出现的原因！

假设我们在玩围棋，棋盘是11*11，用0表示空位，1表示黑棋，2表示蓝棋。那用普通数组储存是不是会有很多0在占用空位，使得内存增加。所以当一个数组中有很多0的时候，为节省内存稀疏数组就应运而生了。

前言2：什么是稀疏数组？

稀疏数组也是数组的一种，行数代表普通二维数组中的非零值个数，我称之为有效数，列数固定是三列。第一列是有效数的行，第二列是有效数的列，第三列就是有效数的值。用每一行来确定一个有效值对应的坐标和值。

1.例子分析

  • 假设棋局如下，如何用普通数组和稀疏数组进行描述？
    在这里插入图片描述

  • 普通二维数组和稀疏数组表示结果的比较。
    在这里插入图片描述在这里插入图片描述

    这对比还得了，吓得我赶紧去学稀疏数组了！

2. 解题过程

1. 用普通数组记录。

首先我们应该创建一个11*11的数组，然后往里面赋值，这个应该很简单。

 // 创建一个11*11的二维数组，用0表示没有棋子，用1表示黑棋，用2表示白棋
        int[][] arrys = new int[11][11];
        arrys[1][2] = 1;
        arrys[2][3] = 2;

2. 打印二维数组元素

 for (int[] arry : arrys) {//遍历行
            for (int i : arry) {//遍历列
                System.out.print(i + " ");
            }
            System.out.println();//遍历完一行之后就换行
        }
    System.out.println("==============================");//可以选择输出分割线表示美观

3. 用稀疏数组表示

  • 遍历普通数组元素的非零值个数

    //遍历有效值个数
        int sum = 0;//用于计算元素的非零值个数
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (arrys[i][j]!= 0){
                    sum ++;
                }
            }
        }

  • 创建稀疏数组并给首行，即给第0行赋值

    //创建稀疏数组并给首行，即使第0行赋值
        int[][] arr = new int[sum+1][3];
        arr[0][0] = 11;
        arr[0][1] = 11;
        arr[0][2] = sum;

  • 给稀疏数组其他行赋值，列数是固定的。

    //遍历二维数组，将值存放到稀疏数组中
        int count = 0;
        for (int i = 0; i < arrys.length; i++) {
            for (int j = 0; j < arrys[i].length; j++) {
                if (arrys[i][j] != 0 ){
                    count ++;
                    arr[count][0] = i;
                    arr[count][1] = j;
                    arr[count][2] = arrys[i][j];
                }
            }
        }

4. 打印稀疏数组

//输出稀疏数组
        System.out.println("输出稀疏数组:");
        System.out.println("行" + "\t" + "列" + "\t" + "有效数字");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < 3 ; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }

到这里我们其实已经把这题解出来了，但是我们能不能把数组还原回去呢？答案是：当然能！

3.还原数组

  • 读取原来数组的长和宽

    //读取稀疏数组还原原来数组的长和宽
        int[][] arry = new int[arr[0][0]][arr[0][1]];

  • 还原其中的值

    //还原其中的值
        for (int i = 1; i < arr.length ; i++) {
            arry[arr[i][0]][arr[i][1]] = arr[i][2];
        }

  • 打印数组

    //打印还原后的稀疏数组
        System.out.println("打印还原后的稀疏数组:");
        for (int[] arry1 : arry) {
            for (int i : arry1) {
                System.out.print( i + " ");
            }
            System.out.println();
        }
        System.out.println("==============================");

完了吗？还没完，这样麻烦对不对，那我们将它们打包成方法吧

4. 整理后代码

/**
 * 二维数组和稀疏数组
 */
public class Demon3 {
    public static void main(String[] args) {
        // 创建一个11*11的二维数组，用0表示没有棋子，用1表示黑棋，用2表示白棋
        int m = 11, n = 11;//用来设置棋盘的大小
        int[][] arrys = new int[m][n];
        arrys[1][2] = 1;
        arrys[2][3] = 2;
       PrintArry(arrys);//打印二维数组
       int[][] arr =  RewordArry(m,n,arrys);//将二维数组转换成一个稀疏数组并返回,用一个数组接收
       PrintEspecialArry(arr);//打印稀疏数组
       int[][] arr1 = ReturnArry(arr);//将稀疏数组还原为一个二维数组，并用一个数组接收
        PrintArry(arr1);//打印二维数组
       PrintArry(ReturnArry(arr));//也可以直接调用打印方法接收对象

    }

    /**
     * 打印二维数组的方法
     * @param arry1
     */
    public static void PrintArry ( int[][] arry1){//传入一个二维数组
        System.out.println("二维数组如下");
        for (int[] arry : arry1) {//遍历数组的行
            for (int i : arry) {//遍历数组的列
                System.out.print(i + " ");
            }
            System.out.println();//遍历完一行后换行
        }
        System.out.println("==============================");//输出分割线让界面美观
    }

    /**
     * 转换成稀疏数组的方法
     *
     * @param m
     * @param n
     * @param arry2
     * @return
     */
    public static int[][] RewordArry ( int m, int n, int[][] arry2){
        //遍历有效值个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (arry2[i][j] != 0) {
                    sum++;
                }
            }
        }
        //转换为稀疏数组
        int[][] arr = new int[sum + 1][3];
        arr[0][0] = m;
        arr[0][1] = n;
        arr[0][2] = sum;
        //遍历二维数组，将值存放到稀疏数组中
        int count = 0;
        for (int i = 0; i < arry2.length; i++) {
            for (int j = 0; j < arry2[i].length; j++) {
                if (arry2[i][j] != 0) {
                    count++;
                    arr[count][0] = i;
                    arr[count][1] = j;
                    arr[count][2] = arry2[i][j];
                }
            }
        }
        return arr;
    }

    /**
     * 打印稀疏数组
     * @param arry3
     */
    public static void PrintEspecialArry ( int[][] arry3){
        System.out.println("输出稀疏数组:");
        System.out.println("行" + "\t" + "列" + "\t" + "有效数字");
        for (int i = 0; i < arry3.length; i++) {
            for (int j = 0; j < 3; j++) {//稀疏数组固定长度为三
                System.out.print(arry3[i][j] + "\t");
            }
            System.out.println();
        }
        System.out.println("==============================");
    }

    /**
     * 还原数组
     * @param arry4
     * @return
     */
    public static int[][] ReturnArry ( int[][] arry4){
        //读取稀疏数组还原原来数组的长和宽
        int[][] arry = new int[arry4[0][0]][arry4[0][1]];
        //还原其中的值
        for (int i = 1; i < arry4.length; i++) {
            arry[arry4[i][0]][arry4[i][1]] = arry4[i][2];
        }
        return arry;
    }
}

全码终！

彩蛋之送你一个有趣的注释：码农必备

/***
 *                                 _ooOoo_
 *                                o8888888o
 *                                88" . "88
 *                                (| -_- |)
 *                                 O\ = /O
 *                             ____/`---'\____
 *                           .   ' \\| |// `.
 *                            / \\||| : |||// \
 *                          / _||||| -:- |||||- \
 *                            | | \\\ - /// | |
 *                          | \_| ''\---/'' | |
 *                           \ .-\__ `-` ___/-. /
 *                        ___`. .' /--.--\ `. . __
 *                     ."" '< `.___\_<|>_/___.' >'"".
 *                    | | : `- \`.;`\ _ /`;.`/ - ` : | |
 *                      \ \ `-. \_ __\ /__ _/ .-` / /
 *              ======`-.____`-.___\_____/___.-`____.-'======
 *                    `=---='
 *
 *               .............................................
 *                       佛祖保佑             永无BUG
 */

大家晚安，头发重要！

BKSW.
关注
【大数据】稀疏位图存储、RoaringBitmap、布隆过滤器，判断元素是否在集合、精确去重
九师兄
07-25 131
是一种基于位图的数据结构，可以高效地存储大量的非负整数，并支持多种集合运算，如并集、交集、差集等。它可以高效地判断一个元素是否在集合中，并且可以使用很少的空间来存储集合。本文阐述了 RoaringBitmap的基础原理、数据结构和 Container 源码，也列举了 Go 语言常用的位运算。因为最近在业务场景里使用到了 RoaringBitmap。在大数据的应用场景使用 RoaringBitmap 确实能够达到降本增效的作用。
稀疏数组
小杰瑞_
08-15 196
当一个数组中大部分元素为0，或者为同一个值得数组，可以使用稀疏数组来保存该数组。
用时间置换空间，聊聊稀疏数组的那些事儿
qq_46388795的博客
09-28 173
背景 数据结构是指带有结构特性的数据元素的集合。在数据结构中，数据之间通过一定的组织结构关联在一起，便于计算机存储和使用。从大类划分，数据结构可以分为线性结构和非线性结构，适用于不同的应用场景。 线性结构： 　　线性结构作为最常用的数据结构，它的特点是单个数据之间存在一对一的线性关系。包含两种不同的存储结构：顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的。 （线性结构） 　　链式存储的线性表被叫做链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及
那我们来聊聊HashMap(浅谈）和hash算法？
m0_46741750的博客
03-26 1313
文章目录1.简介2.数据结构 1.简介 首先，我们今天主要的讲解还是hash算法，但是需要注意的就是，即使利用hash算法，计算出来的hashcode值，可能也会出现相同的情况。 hashmap作为java中非常重要的数据结构，对于key-value类型的存储（缓存，临时映射表，。。。）等不可或缺，hashmap本身是非线程安全的，对于多线程条件下需要做竞争条件处理，可以通过Collections和ConcurrentHashmap来替代。 2.数据结构 hashmap存储数据主要是通过数组+链表实现的
【JavaScript】2.复杂数据类型：数组和对象
M&Q的博客
04-17 604
三、对象 对象是一个非常重要的概念，一定要灵活掌握： 对象：属性的无序集合，当属性值为函数的时候，我们叫这个函数为对象的方法。 数组：元素的有序集合。了解数组的常用方法 日期对象：获取年月日时分秒 数学对象：获取随机数 了解其他对象：正则表达式、包装对象，其实函数也是对象，不过这些简单了解一下就行。 作者：李吉阳 链接：https://zhuanlan.zhihu.com/p/...
聊聊java中的哪些Map：（八）ConcurrentSkipListMap源码分析
m0_71563599的博客
06-04 220
在java Concurrnet包中，还有另外一个Map，这就是ConcurrentSkipListMap。这是一种采用了跳表的数据结构，也是redis中最常用的数据结构，今天来分析下这个并发容器。ConcurrentSkipListMap也是java并发包下面的重要容器，其类的继承结构如下：可以看到，ConcurrentSkipListMap的类的继承结构会比ConcurrentHashMap复杂一些。除了要继承AbstractMap类之外，还需要实现ConcurrentNavigableMap、Clon
学习数据结构Day1
oasisdd的博客
08-06 132
数据结构概述及稀疏矩阵的概述 数据结构的分类 1. 线性结构 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系 线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。 顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及 相邻元素的地址信息 线性结构常见的有：数组、队列、链表和栈...
按身高排列
HUOYUQI的博客
10-07 454
int[][] a = {{7,0}, {4,4}, {7,1}, {5,0}, {6,1}, {5,2}}; Arrays.sort(a,(o1,o2)->o1[0] == o2[0] ? o1[1] - o2[1] : o2[0] - o1[0]); List<int[]> list = new LinkedList<>(); for(int[] p:a){ list.add(p[1],p); } System.out.println(list);
2023聊聊web前端的昨天今天和明天
最新发布
09-18
昨天，Web前端是一个非常基础的领域，主要关注页面的布局和样式。在这个阶段，主要使用HTML和CSS来创建网页，JavaScript主要用于增加一些动态效果。当时，前端开发主要集中在PC端的网站上。 今天，Web前端发生了...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值