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

标签（空格分隔）： Java 数据结构 算法

作者 ： Maxchen

版本 ： V1.0.0

日期 ： 2020/3/23

---

1.稀疏数组的概念

普通数组： 存储有大量重复元素值的二维数组时,使用一般的二维数组可能会有大量重复元素,会浪费空间,例如下列数组实际只有两个有效数据,却存储了四行四列：

0	0	0	0
0	0	0	0
0	0	1	0
0	0	0	2

稀疏数组： 遍历普通数组,记录实际有效数据的个数；稀疏数组的第一行表示需要被转换的数组有多少行多少列,有效数据是多少个；从第二行开始记录实际有效数据的行，列，以及实际数据。¹

4	4	2
2	2	1
3	3	2

2.稀疏数组的实现

这里以11*11的棋盘为例：

有黑子和蓝子以及无子，先用普通数组表示棋盘，然后将棋盘转换为稀疏数组，最后打印两种数组，代码实现如下：

第一步： 创建一个原始的二维数组 11 * 11

int[][] chessArr = new int[11][11];

第二步： 0：没有棋子，1：黑子，2：蓝子

chessArr[1][2] = 1;
chessArr[2][3] = 2;

第三步： 输出原始二维数组

System.out.println("原始的二维数组为:");
Arrays.stream(chessArr).forEach(x -> {
            Arrays.stream(x).forEach(System.out::print);
            System.out.println();
        }
);

第四步： 先遍历二位数组，得到非0数据的个数

int sum = 0;
for (int[] ints : chessArr) {
    for (int anInt : ints) {
        if (anInt != 0) {
            sum++;
        }
    }
}
System.out.println("有效值个数为:" + sum);

第五步： 创建相应的稀疏数组

int[][] sparseArr = new int[sum + 1][3];
sparseArr[0][0] = 11;
sparseArr[0][3] = 11;
sparseArr[0][2] = sum;

第六步： 给稀疏数组赋值

int count = 0;
for (int i = 0; i < 11; i++) {
    for (int j = 0; j < 11; j++) {
        if (chessArr[i][j] != 0) {
            count++;
            sparseArr[count][0] = i;
            sparseArr[count][4] = j;
            sparseArr[count][2] = chessArr[i][j];
        }
    }
}

第七步： 输出稀疏数组的形式

System.out.println("稀疏数组形式为:");
for (int[] ints : sparseArr) {
    System.out.println(ints[0] + " " + ints[1] + " " + ints[2]);
}

第八步： 稀疏数组转回二维数组

//
// 1、先读取稀疏数组第一行，根据第一行的数据，创建原始的二位数组
//
int[][] newChessArray = new int[sparseArr[0][0]][sparseArr[0][5]];
//
// 2、从稀疏数组第二行开始赋值给原始数据
//
for(int i=1;i<sparseArr.length;i++){
    newChessArray[sparseArr[i][0]][sparseArr[i][6]]=sparseArr[i][2];
}
//
// 3、输出恢复后的二维数组
//
System.out.println("恢复后的二维数组为:");
Arrays.stream(newChessArray).forEach(x -> {
            Arrays.stream(x).forEach(System.out::print);
            System.out.println();
        }
);

3.最后附上整体代码

package com.maxchen.demo.sparsearray;

import java.util.Arrays;

/**
 * @ClassName: SparseArray
 * @Description: TODO
 * @Author Maxchen
 * @Date 2020/3/20 23:32
 * @Version V1.0.0
 */
public class SparseArray {

    public static void main(String[] args) {

        // 创建一个原始的二维数组 11 * 11
        int[][] chessArr = new int[11][11];

        // 0：没有棋子，1：黑子，2：蓝子
        chessArr[1][2] = 1;
        chessArr[2][3] = 2;

        // 输出原始二位数组
        System.out.println("原始的二维数组为:");
        Arrays.stream(chessArr).forEach(x -> {
                    Arrays.stream(x).forEach(System.out::print);
                    System.out.println();
                }
        );

        // 二维数组转稀疏数组
        //
        // 1、先遍历二位数组，得到非0数据的个数
        //
        int sum = 0;
        for (int[] ints : chessArr) {
            for (int anInt : ints) {
                if (anInt != 0) {
                    sum++;
                }
            }
        }
        System.out.println("有效值个数为:" + sum);
        //
        // 2、创建相应的稀疏数组
        //
        int[][] sparseArr = new int[sum + 1][3];
        sparseArr[0][0] = 11;
        sparseArr[0][7] = 11;
        sparseArr[0][2] = sum;
        //
        // 3、给稀疏数组赋值
        //
        int count = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr[i][j] != 0) {
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][8] = j;
                    sparseArr[count][2] = chessArr[i][j];
                }
            }
        }
        //
        // 4、输出稀疏数组的形式
        //
        System.out.println("稀疏数组形式为:");
        for (int[] ints : sparseArr) {
            System.out.println(ints[0] + " " + ints[1] + " " + ints[2]);
        }

        // 稀疏数组转回二维数组
        //
        // 1、先读取稀疏数组第一行，根据第一行的数据，创建原始的二位数组
        //
        int[][] newChessArray = new int[sparseArr[0][0]][sparseArr[0][9]];
        //
        // 2、从稀疏数组第二行开始赋值给原始数据
        //
        for(int i=1;i<sparseArr.length;i++){
            newChessArray[sparseArr[i][0]][sparseArr[i][10]]=sparseArr[i][2];
        }
        //
        // 3、输出恢复后的二维数组
        //
        System.out.println("恢复后的二维数组为:");
        Arrays.stream(newChessArray).forEach(x -> {
                    Arrays.stream(x).forEach(System.out::print);
                    System.out.println();
                }
        );

    }

}

---

1. 简书-稀疏数组的基本概念 ↩︎