数据结构与算法之稀疏数组（java代码实现）

稀疏数组

稀疏数组的应用

棋盘问题：如棋盘的保存，悔棋如何实现

棋盘相当于一个二维数组，要实现棋盘的保存和悔棋等功能就相当于对二维数组进行存储，读取操作，一枚棋子相当于一个有效数据

例如：黑白棋中黑棋相当于数组中的数字1，白棋相当于数组中的数字2，没有棋子的地方就是0，而1和2称为有效数据，0称为无效数据，在存储的时候

为了节省内存空间和加快存储的效率，只存储有效数据，而如何实现只存储有效数据呢？这就需要用到稀疏数组

稀疏数组如何实现

这是一个8行8列的棋盘，共有四个棋子（白棋2两个，黑棋1两个）

 

使用数组来表示就是

 

 

 存储总不能存那么多重复且没有实际用处的0吧，所以使用稀疏数组，那么问题来了，怎么使用稀疏数组呢

先看稀疏数组和二维数组的关系吧

 

 通过上图可以看出，稀疏数组存储了二维数组的基本信息，如：共有几行几列，以及有效数据和有效数据的存储位置

代码如何实现呢？（截取部分有效代码）

二维数组转换为稀疏数组

步骤

1、遍历二维数组得到有效数据的个数sum

2、根据遍历二维数组得到的有效数据的个数创建稀疏数组sparseArr[sum+1][3]

3、将二维数组的有效数据存储到稀疏数组中

//创建旧数组
        int[][] oldArr = new int[8][8];
        //填充数据
        oldArr[3][3] = 2;
        oldArr[3][4] = 1;
        oldArr[4][3] = 1;
        oldArr[4][4] = 2;

        //1、获取有效数据有多少
        int effectiveNum = 0;
        for (int[] i:oldArr) {
            for (int n:i) {
                if (n != 0){
                    //不为0表示数据有效
                    effectiveNum += 1;
                }
                System.out.print(n);
                System.out.print("\t");
            }
            System.out.println();
        }
        System.out.println("-----------------------------");

        //创建用于存储的稀疏数组
        int[][] sparseArr = new int[effectiveNum + 1][3];
        //为稀疏数组赋值
        sparseArr[0][0] = oldArr.length;
        sparseArr[0][1] = oldArr[0].length;
        sparseArr[0][2] = effectiveNum;
        int num = 1;
        for (int i = 0; i < oldArr.length; i++) {
            for (int j = 0; j < oldArr[i].length; j++) {
                if (oldArr[i][j] != 0){
                    sparseArr[num][0] = i;
                    sparseArr[num][1] = j;
                    sparseArr[num][2] = oldArr[i][j];
                    num += 1;
                }
            }
        }

        for (int[] i:sparseArr) {
            for (int n:i) {
                System.out.print(n);
                System.out.print("\t");
            }
            System.out.println();
        }
        System.out.println("-----------------------------");

结果

 

 稀疏数组转换为二维数组

步骤

1、根据稀疏数组的第一行的数据创建二维数组，newArr

2、遍历稀疏数组将值赋给newArr二维数组

//稀疏数组转换为普通二维数组
        int[][] newArr = new int[sparseArr[0][0]][sparseArr[0][1]];

        for (int i = 1; i < sparseArr.length; i++) {
            newArr[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }

        for (int[] i:newArr) {
            for (int n:i) {
                System.out.print(n);
                System.out.print("\t");
            }
            System.out.println();
        }

结果

 

 完整代码

public class SparseArray {
    public static void main(String[] args) {
        //创建旧数组
        int[][] oldArr = new int[8][8];
        //填充数据
        oldArr[3][3] = 2;
        oldArr[3][4] = 1;
        oldArr[4][3] = 1;
        oldArr[4][4] = 2;

        //1、获取有效数据有多少
        int effectiveNum = 0;
        for (int[] i:oldArr) {
            for (int n:i) {
                if (n != 0){
                    //不为0表示数据有效
                    effectiveNum += 1;
                }
                System.out.print(n);
                System.out.print("\t");
            }
            System.out.println();
        }
        System.out.println("-----------------------------");

        //创建用于存储的稀疏数组
        int[][] sparseArr = new int[effectiveNum + 1][3];
        //为稀疏数组赋值
        sparseArr[0][0] = oldArr.length;
        sparseArr[0][1] = oldArr[0].length;
        sparseArr[0][2] = effectiveNum;
        int num = 1;
        for (int i = 0; i < oldArr.length; i++) {
            for (int j = 0; j < oldArr[i].length; j++) {
                if (oldArr[i][j] != 0){
                    sparseArr[num][0] = i;
                    sparseArr[num][1] = j;
                    sparseArr[num][2] = oldArr[i][j];
                    num += 1;
                }
            }
        }

        for (int[] i:sparseArr) {
            for (int n:i) {
                System.out.print(n);
                System.out.print("\t");
            }
            System.out.println();
        }
        System.out.println("-----------------------------");

        //稀疏数组转换为普通二维数组
        int[][] newArr = new int[sparseArr[0][0]][sparseArr[0][1]];

        for (int i = 1; i < sparseArr.length; i++) {
            newArr[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }

        for (int[] i:newArr) {
            for (int n:i) {
                System.out.print(n);
                System.out.print("\t");
            }
            System.out.println();
        }
    }
}