java稀疏数组

本文介绍了稀疏数组的概念及其应用场景,特别是在存储大量相同值(如零)的数组时的优势。通过实例演示了如何将一个二维数组转化为稀疏数组,并提供代码实现,最后再将稀疏数组还原成原始的二维数组。

         稀疏数组的介绍:当一个数组中大部分的数据都为0或同一个值时我们可以使用稀疏数组来保存这个数组;

       

在侧边栏查询中搜索

         就好比我们的棋盘,他可以看成为一个二维数组,但这给棋盘上有的大部分的位置是没有棋子的。将他转为二维数组来储存时就有点浪费了,我们可以按照稀疏数组来储存棋盘上的数据。

        稀疏数组的处理方式:

1.纪录数组一个有多少行多少列多少个值。

2.把具有不同值的元素纪录在小规模的数组中,从而缩小程序的规模。

                                           

我们可以将一个二维数组转换为如右一样的稀疏数组。

 代码介绍:

//          先创建一个二维数组
//        0代表没有旗子1代表黑棋2代表白棋
        int[][] arr = new int[11][11];
        arr[5][5] = 1;
        arr[6][6] = 2;
        for (int[] row : arr) {
            for (int a : row) {
                System.out.print(a);
            }
            System.out.println();
        }
//        将二维数组转为稀疏数组
//        先定义一个数来纪录有多少个不为0的数
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("sum=" + sum);
//        创建稀疏数组
        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 < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] != 0) {
                    count++;
                    SparseArray[count][0] = i;
                    SparseArray[count][1] = j;
                    SparseArray[count][2] = arr[i][j];
                }
            }
        }
//        打印稀疏数组
        System.out.println("打印后的稀疏数组");
        for(int[] row:SparseArray){
            for(int a:row){
                System.out.print(a+"  ");
            }
            System.out.println();
        }

//        将稀疏数组恢复成为二维数组
//        按照稀疏数组的第一列中储存的数据来创建一个二维数组 一维的长度为稀疏数组的第一行的第一列的值
//        二维的长度为稀疏数组的第一行的第二列的值
        int[][] arr2 = new int[SparseArray[0][0]][SparseArray[0][1]];//此时这个二维数组还只是空的
//        现在将数据添加
         for (int i=1;i<SparseArray.length;i++){
             arr2[SparseArray[i][0]][SparseArray[i][1]]=SparseArray[i][2];
         }
        System.out.println("恢复完后的二维数组");
        for(int[] row:arr2){
            for(int a:row){
                System.out.print(a);
            }
            System.out.println();
        }

<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
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值