29 java数组_8 _稀疏数组

java数组_8 _稀疏数组

介绍

  1. 稀疏数组是一种数据结构

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

  3. 稀疏数组的处理方式为:

    1. 记录数组一共有几行几列,有多少个不同值
    2. 把具有不同值的元素和行列及值记录在一个小规模的数组中,从而缩小程序的规模
  4. 如下图:左边是原始数组,右边是稀疏数组

在这里插入图片描述

例子:(记录棋盘)

在这里插入图片描述

package com.wlw.arrays;

public class ArraysDemo08 {
    public static void main(String[] args) {
        //1.创建一个二维数组,11*11  0:没有棋子  1:黑棋  2:白棋
        int[][] a1 = new int[11][11];
        a1[1][2] = 1;
        a1[2][3] = 2;

        System.out.println("输出原始数组:" );
/*        for (int[] ints : a1) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }*/

        for (int i = 0; i < a1.length; i++) {
            for (int j = 0; j < a1[i].length; j++) {
                System.out.print(a1[i][j] + " ");
            }
            System.out.println();
        }

        System.out.println("================================");

        //转换为稀疏数组
        //1.先来计算原数组有几个非0数(有效值)
        int sum = 0;
        for (int i = 0; i < a1.length; i++) {
            for (int j = 0; j < a1[i].length; j++) {
                if (a1[i][j] != 0) {
                    sum++;
                }
            }
        }

        System.out.println("原数组中有效值的个数为:"+sum);

        //2.创建稀疏数组,稀疏数组就3列是确定的
        int[][] a2 = new int[sum+1][3];
        a2[0][0] = a1.length;
        a2[0][1] = a1[0].length;
        a2[0][2] = sum;

        //3.存放原数组有效值的行列及值
        int count = 0;
        for (int i = 0; i < a1.length; i++) {
            for (int j = 0; j < a1[i].length; j++) {
                if(a1[i][j] != 0 ){
                    count++;
                    a2[count][0] = i;
                    a2[count][1] = j;
                    a2[count][2] = a1[i][j];
                }
            }
        }

        //4.输出稀疏数组
        System.out.println("稀疏数组:");
        for (int i = 0; i < a2.length; i++) {
            System.out.println(a2[i][0] + "\t" + a2[i][1] + "\t" + a2[i][2] + "\t");
        }
        /*for (int[] ints : a2) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }*/

        System.out.println("================================");
        System.out.println("还原");

        //1.创建一个数组
        int[][] a3 = new int[a2[0][0]][a2[0][1]];

        //2.赋值
        for (int i = 1; i < a2.length; i++) {
            a3[a2[i][0]][a2[i][1]] = a2[i][2];
        }

        //3.输出
        for (int[] ints : a3) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            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 
    ================================
    原数组中有效值的个数为:2
    稀疏数组:
    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 

*/


<think> 根据用户需求,用户希望了解Java稀疏数组的介绍、使用方法及示例。结合提供的引用内容,我将系统性地组织回答。 首先,稀疏数组是一种优化存储空间的数据结构,特别适用于元素大部分为零(或相同值)的二维数组。在Java中,稀疏数组通常使用一个三元组(行、列、值)来表示非零元素的位置和值。 ### 一、稀疏数组介绍 稀疏数组的核心思想是只存储非默认值(通常是非零)的元素,从而节省内存空间。它包含三个关键部分: 1. **元数据行**:存储原始数组的行数、列数及非默认值的总数 2. **数据行**:每行存储一个非默认值元素的行索引、列索引和实际值 例如,原始数组: ``` 0 0 3 0 0 0 5 0 0 ``` 对应的稀疏数组为: ``` 3 3 2 // 共3行3列,有2个非零元素 0 2 3 // 第0行第2列值为3 2 0 5 // 第2行第0列值为5 ``` ### 二、使用方法 在Java中实现稀疏数组转换包含两个核心方法: 1. **原始数组稀疏数组**: - 遍历原始数组统计非零元素数量 - 创建稀疏数组(行数为非零元素数+1,列数固定为3) - 填充数据 2. **稀疏数组还原为原始数组**: - 读取稀疏数组首行获取原始数组维度 - 创建原始数组 - 遍历稀疏数组剩余行填充数据 ### 三、代码示例 基于引用[3]的代码框架补充完整实现: ```java public class SparseArrayDemo { public static void main(String[] args) { // 创建原始数组 11x11 int[][] chessArray = new int[11][11]; chessArray[1][2] = 1; // 黑子 chessArray[2][3] = 2; // 蓝子 // 转换为稀疏数组 int[][] sparseArray = toSparseArray(chessArray); // 输出稀疏数组 System.out.println("稀疏数组:"); for (int[] row : sparseArray) { System.out.printf("%d\t%d\t%d\n", row[0], row[1], row[2]); } // 还原为原始数组 int[][] restoredArray = toOriginalArray(sparseArray); // 验证还原 System.out.println("还原后的数组:"); for (int[] row : restoredArray) { for (int data : row) { System.out.printf("%d\t", data); } System.out.println(); } } // 原始数组稀疏数组 public static int[][] toSparseArray(int[][] original) { int sum = 0; // 统计非零元素数量 for (int[] row : original) { for (int data : row) { if (data != 0) sum++; } } // 创建稀疏数组 int[][] sparseArray = new int[sum + 1][3]; sparseArray[0][0] = original.length; sparseArray[0][1] = original[0].length; sparseArray[0][2] = sum; // 填充非零元素 int count = 0; for (int i = 0; i < original.length; i++) { for (int j = 0; j < original[i].length; j++) { if (original[i][j] != 0) { count++; sparseArray[count][0] = i; sparseArray[count][1] = j; sparseArray[count][2] = original[i][j]; } } } return sparseArray; } // 稀疏数组还原 public static int[][] toOriginalArray(int[][] sparseArray) { int rows = sparseArray[0][0]; int cols = sparseArray[0][1]; int[][] original = new int[rows][cols]; for (int i = 1; i < sparseArray.length; i++) { int row = sparseArray[i][0]; int col = sparseArray[i][1]; int value = sparseArray[i][2]; original[row][col] = value; } return original; } } ``` ### 四、应用场景 1. 棋盘类游戏(如五子棋)的状态存储 2. 图像处理中稀疏矩阵的压缩存储 3. 科学计算中大型稀疏数据集的存储优化 ### 五、注意事项 1. 当非零元素超过总元素量的$1/3$时,使用稀疏数组可能反而增加内存消耗 2. 稀疏数组的随机访问效率低于原始数组 §§相关问题§§ 1. Java中如何优化超大稀疏矩阵的运算性能? 2. 稀疏数组与其他压缩存储结构(如压缩行存储)有何区别? 3. 在实际项目中如何选择是否使用稀疏数组? </think>### Java稀疏数组详解 #### 一、稀疏数组介绍 稀疏数组(Sparse Array)是一种优化存储空间的数据结构,适用于**元素大部分为零(或相同默认值)的二维数组**。核心思想是仅存储非默认值元素的位置和值,从而显著减少内存占用。典型应用场景包括: - 棋盘类游戏(如围棋、五子棋)的状态存储 - 图像处理中的稀疏矩阵 - 科学计算中的大型稀疏数据集 **存储结构**: 1. **首行**:存储原始数组的总行数、总列数、非默认值元素个数 2. **后续行**:每行存储一个非默认值元素的行索引、列索引和值 例如原始数组: ``` 0 0 0 5 0 0 0 0 9 0 0 0 ``` 转换为稀疏数组: ``` 3 4 2 // 共3行4列,2个非零元素 0 3 5 // 第0行第3列值为5 2 0 9 // 第2行第0列值为9 ``` #### 二、使用方法(Java实现) ##### 1. 原始数组稀疏数组 ```java public int[][] toSparseArray(int[][] originalArray) { // 统计非零元素数量 int count = 0; for (int[] row : originalArray) { for (int val : row) { if (val != 0) count++; } } // 创建稀疏数组(行数=非零元素+1,列数固定为3) int[][] sparseArray = new int[count + 1][3]; sparseArray[0][0] = originalArray.length; // 原始数组行数 sparseArray[0][1] = originalArray[0].length; // 原始数组列数 sparseArray[0][2] = count; // 非零元素总数 // 填充非零元素数据 int index = 1; for (int i = 0; i < originalArray.length; i++) { for (int j = 0; j < originalArray[i].length; j++) { if (originalArray[i][j] != 0) { sparseArray[index][0] = i; // 行索引 sparseArray[index][1] = j; // 列索引 sparseArray[index][2] = originalArray[i][j]; // 值 index++; } } } return sparseArray; } ``` ##### 2. 稀疏数组 → 原始数组 ```java public int[][] toOriginalArray(int[][] sparseArray) { // 读取原始数组维度 int rows = sparseArray[0][0]; int cols = sparseArray[0][1]; int[][] originalArray = new int[rows][cols]; // 填充非零元素 for (int i = 1; i < sparseArray.length; i++) { int rowIdx = sparseArray[i][0]; int colIdx = sparseArray[i][1]; int value = sparseArray[i][2]; originalArray[rowIdx][colIdx] = value; } return originalArray; } ``` #### 三、完整示例 ```java public class SparseArrayDemo { public static void main(String[] args) { // 1. 创建原始数组(11x11棋盘) int[][] chessboard = new int[11][11]; chessboard[1][2] = 1; // 黑子 chessboard[2][3] = 2; // 白子 // 2. 转换为稀疏数组 int[][] sparseArr = toSparseArray(chessboard); // 打印稀疏数组 System.out.println("稀疏数组结构:"); for (int[] row : sparseArr) { System.out.printf("%d\t%d\t%d\n", row[0], row[1], row[2]); } /* 输出: 11 11 2 // 首行元数据 1 2 1 // 第1行第2列黑子 2 3 2 // 第2行第3列白子 */ // 3. 还原原始数组 int[][] restoredArray = toOriginalArray(sparseArr); } // 此处插入上述转换方法 } ``` #### 四、关键优化点 1. **空间效率**:当非零元素占比小于 $\frac{1}{3}$ 时,空间优化效果显著 2. **序列化优势**:稀疏数组更适合文件存储/网络传输 3. **适用场景**:适用于读多写少的场景,频繁修改会降低性能 > **注意事项**:当数据稠密(非零元素超过30%)时,稀疏数组可能反而增加内存开销[^4]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

悬浮海

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值