Java数据结构与算法分析(二)稀疏数组

简介: 在介绍稀疏数组前我们先来引入一个需求,下面是一个五子棋的棋盘(15 * 15),玩到中途时想要保存离开,希望下次打开还可以继续玩。我们怎么实现呢?

GitHub源码分享

项目主页:https://github.com/gozhuyinglong/blog-demos
本文源码:https://github.com/gozhuyinglong/blog-demos/tree/main/java-data-structures

五子棋游戏的存取需求

在介绍稀疏数组前我们先来引入一个需求,下面是一个五子棋的棋盘(15 * 15),玩到中途时想要保存离开,希望下次打开还可以继续玩。我们怎么实现呢?

81c19d8f479619930fcc273b68662268_watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvemh1eWluZ2xvbmc=,size_16,color_FFFFFF,t_70#pic_center.jpg

从对棋盘的观察来看,我们可以使用int型的二维数组进行存储,将未落子的地方存储0,白子存储1,黑子存储2,那么我们的数组可能是这样的:

1a67f4b84be40de13f6f5fdb5e17bc54_watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dvemh1eWluZ2xvbmc=,size_16,color_FFFFFF,t_70#pic_center.png

可以看出,使用二维数组是能解决这个需求的。但我们也发现了一个问题,上面存储相同数值的0比较多,这对空间造成了浪费,有没有另外一种存储方式呢?答案是可以使用稀疏数组,下面我们来看稀疏数组是怎么实现的!

稀疏数组(Sparse Array)

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

稀疏数组的处理方式是:

  1. 记录数组一共有几行几列,以及不同值的数量
  2. 把具有不同值元素的行列及其值记录在一个小规模的数组中,从而缩小数据的规模。

那我们把上面二维数组转为稀疏数组存储,看是什么样子的。

稀疏数组存储结构

第一行(即:0行)比较特殊,row存储总行数,col存储总列数,value存储非零(不同值)元素的数量;
其他行结构相同,每一行存储一条非零元素信息,row存储元素所在行,col存储元素所在列,value存储元素的值。

代码实现

我们使用代码来实现二维数组与稀疏数组的相互转换,下面是具体的实现!

public class SparseArrayDemo {
   
   

    public static void main(String[] args) {
   
   
        System.out.println("-----------------------普通数组");
        int[][] initialArray = initArray();
        printArray(initialArray);
        System.out.println("-----------------------普通数组 --> 稀疏数组");
        int[][] sparseArray = arrayConvertSparseArray(initialArray);
        printArray(sparseArray);
        System.out.println("-----------------------稀疏数组 --> 普通数组");
        int[][] array = sparseArrayConvertArray(sparseArray);
        printArray(array);
    }

    /**
     * 初始化五子棋数组
     *
     * @return
     */
    static int[][] initArray() {
   
   
        // 0为空,1为白子,2为黑子
        int[][] array = new int[15][15];
        array[3][11] = 1;
        array[4][10] = 2;
        array[5][9] = 2;
        array[6][8] = 2;
        array[6][7] = 1;
        array[7][8] = 1;
        array[7][7] = 2;
        array[8][6] = 1;
        return array;
    }

    /**
     * 打印二维数组
     *
     * @param array
     */
    static void printArray(int[][] array) {
   
   
        for (int[] row : array) {
   
   
            for (int data : row) {
   
   
                System.out.printf("%s\t", data);
            }
            System.out.println();
        }
    }

    /**
     * 统计非零值数量
     *
     * @param array
     * @return
     */
    static int valueCount(int[][] array) {
   
   
        int count = 0;
        for (int[] row : array) {
   
   
            for (int data : row) {
   
   
                if (data != 0) {
   
   
                    count++;
                }
            }
        }
        return count;
    }

    /**
     * 普通数组转为稀疏数组
     *
     * @param array
     * @return
     */
    static int[][] arrayConvertSparseArray(int[][] array) {
   
   
        int rowNum = array.length;
        int colNum = array[0].length;
        int valueNum = valueCount(array);

        int[][] sparseArray = new int[valueNum + 1][3];
        sparseArray[0][0] = rowNum;
        sparseArray[0][1] = colNum;
        sparseArray[0][2] = valueNum;

        int rowCount = 1;
        for (int i = 0; i < array.length; i++) {
   
   
            for (int j = 0; j < array[i].length; j++) {
   
   
                int value = array[i][j];
                if (value != 0) {
   
   
                    sparseArray[rowCount][0] = i;
                    sparseArray[rowCount][1] = j;
                    sparseArray[rowCount][2] = value;
                    rowCount++;
                }
            }
        }
        return sparseArray;
    }

    /**
     * 稀疏数组转为普通数组
     *
     * @param sparseArray
     * @return
     */
    static int[][] sparseArrayConvertArray(int[][] sparseArray) {
   
   
        int rowNum = sparseArray[0][0];
        int colNum = sparseArray[0][1];
        int valueNum = sparseArray[0][2];

        int[][] array = new int[rowNum][colNum];

        for (int i = 1; i < valueNum + 1; i++) {
   
   
            int row = sparseArray[i][0];
            int col = sparseArray[i][1];
            int value = sparseArray[i][2];
            array[row][col] = value;
        }

        return array;
    }
}

输出结果:

-----------------------普通数组
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    1    0    0    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    2    0    0    0    0    0    
0    0    0    0    0    0    0    1    2    0    0    0    0    0    0    
0    0    0    0    0    0    0    2    1    0    0    0    0    0    0    
0    0    0    0    0    0    1    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    0    0    0    
-----------------------普通数组 --> 稀疏数组
15    15    8    
3    11    1    
4    10    2    
5    9    2    
6    7    1    
6    8    2    
7    7    2    
7    8    1    
8    6    1    
-----------------------稀疏数组 --> 普通数组
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    1    0    0    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    2    0    0    0    0    0    
0    0    0    0    0    0    0    1    2    0    0    0    0    0    0    
0    0    0    0    0    0    0    2    1    0    0    0    0    0    0    
0    0    0    0    0    0    1    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    0    0    0
相关文章
|
2月前
|
监控 算法 网络协议
Java 实现局域网电脑屏幕监控算法揭秘
在数字化办公环境中,局域网电脑屏幕监控至关重要。本文介绍用Java实现这一功能的算法,涵盖图像采集、数据传输和监控端显示三个关键环节。通过Java的AWT/Swing库和Robot类抓取屏幕图像,使用Socket进行TCP/IP通信传输图像数据,并利用ImageIO类在监控端展示图像。整个过程确保高效、实时和准确,为提升数字化管理提供了技术基础。
86 15
|
1月前
|
存储 Java 索引
Java快速入门之数组、方法
### Java快速入门之数组与方法简介 #### 一、数组 数组是一种容器,用于存储同种数据类型的多个值。定义数组时需指定数据类型,如`int[]`只能存储整数。数组的初始化分为静态和动态两种: - **静态初始化**:直接指定元素,系统自动计算长度,如`int[] arr = {1, 2, 3};` - **动态初始化**:手动指定长度,系统给定默认值,如`int[] arr = new int[3];` 数组访问通过索引完成,索引从0开始,最大索引为`数组.length - 1`。遍历数组常用`for`循环。常见操作包括求和、找最值、统计特定条件元素等。
|
22天前
|
存储 算法 Java
解锁“分享文件”高效密码:探秘 Java 二叉搜索树算法
在信息爆炸的时代,文件分享至关重要。二叉搜索树(BST)以其高效的查找性能,为文件分享优化提供了新路径。本文聚焦Java环境下BST的应用,介绍其基础结构、实现示例及进阶优化。BST通过有序节点快速定位文件,结合自平衡树、多线程和权限管理,大幅提升文件分享效率与安全性。代码示例展示了文件插入与查找的基本操作,适用于大规模并发场景,确保分享过程流畅高效。掌握BST算法,助力文件分享创新发展。
|
1月前
|
存储 Java 索引
Java基础(六):数组
Java基础(六):数组
35 10
Java基础(六):数组
|
1月前
|
存储 人工智能 算法
解锁分布式文件分享的 Java 一致性哈希算法密码
在数字化时代,文件分享成为信息传播与协同办公的关键环节。本文深入探讨基于Java的一致性哈希算法,该算法通过引入虚拟节点和环形哈希空间,解决了传统哈希算法在分布式存储中的“哈希雪崩”问题,确保文件分配稳定高效。文章还展示了Java实现代码,并展望了其在未来文件分享技术中的应用前景,如结合AI优化节点布局和区块链增强数据安全。
|
1月前
|
算法 安全 Java
Java线程调度揭秘:从算法到策略,让你面试稳赢!
在社招面试中,关于线程调度和同步的相关问题常常让人感到棘手。今天,我们将深入解析Java中的线程调度算法、调度策略,探讨线程调度器、时间分片的工作原理,并带你了解常见的线程同步方法。让我们一起破解这些面试难题,提升你的Java并发编程技能!
84 16
|
1月前
|
运维 监控 算法
企业局域网监控软件中 Java 优先队列算法的核心优势
企业局域网监控软件是数字化时代企业网络安全与高效运营的基石,犹如一位洞察秋毫的卫士。通过Java实现的优先队列算法,它能依据事件优先级排序,确保关键网络事件如异常流量、数据泄露等被优先处理,保障系统稳定与安全。代码示例展示了如何定义网络事件类并使用PriorityQueue处理高优先级事件,尤其在面对疑似风险时迅速启动应急措施。这一核心技术助力企业在复杂网络环境中稳健前行,护航业务腾飞。
66 32
|
1月前
|
存储 Java C++
Java数组:静态初始化与动态初始化详解
本文介绍了Java中数组的定义、特点及初始化方式。
73 12
|
1月前
|
存储 监控 算法
剖析基于Java算法驱动的智能局域网管控之道
本文探讨了基于Java语言的局域网控制方案,结合链表数据结构与令牌桶算法,解决设备管理和流量调度难题。通过链表灵活存储网络设备信息,实现高效设备管理;令牌桶算法则精准控制流量,确保网络平稳运行。二者相辅相成,为校园、企业等局域网提供稳固高效的控制体系,保障业务连续性和数据安全。
|
1月前
|
算法 搜索推荐 Java
【潜意识Java】深度解析黑马项目《苍穹外卖》与蓝桥杯算法的结合问题
本文探讨了如何将算法学习与实际项目相结合,以提升编程竞赛中的解题能力。通过《苍穹外卖》项目,介绍了订单配送路径规划(基于动态规划解决旅行商问题)和商品推荐系统(基于贪心算法)。这些实例不仅展示了算法在实际业务中的应用,还帮助读者更好地准备蓝桥杯等编程竞赛。结合具体代码实现和解析,文章详细说明了如何运用算法优化项目功能,提高解决问题的能力。
73 6