Java数据结构之稀疏数组

稀疏数组简述

• 当一个数组元素中大部分元素为0、或者为同一值时、可使用稀疏数组保存数组。即从原数组元素中抽取有效数据、剔除相同元素从而形成一个新的数组。

稀疏数组的处理方式

• 记录数组一共有几行几列、有多少不同的值。
• 把具有不同值元素的行列及值记录在一个小规模的数组中、从而缩小数据的规模。

举例说明

• 以0未落子、 1蓝子、2黑子为例、由整个棋局可转为二维数组(12x12)表示，整合二维数组中除了以落16棋子之外、会造成128个元素浪费。因此可提取原数组中的有效数据形成稀疏数组、从而减少数据规模、节约资源。
  
• 代码示例

package com.hf.structures.sparsearray;

/**
 * @Copyright (C), 2017-2019, Exela-hov
 * @FileName: SparseArray
 * @Author: hf
 * @Date: 2019/7/12 13:45
 * @Description: 二维数组转 稀疏数组
 */
public class SparseArray {

    public static void main(String[] args) {

        System.out.println("------------五子棋盘 原始构建二维数组---------------");
        int[][] arr = createArr();
        showArray(arr);

        System.out.println("------------二维数组 转换 稀疏数组------------------");
        int[][] sparseArr = arrayToSparseArray(arr, 0);
        showArray(sparseArr);

        System.out.println("------------稀疏数组 恢复 二维数组------------------");
        showArray(sparseArrayToArray(sparseArr));
    }

    /**
     * 功能描述: <br>
     * 〈
     * 构建原始二维数组
     * <p>
     * 构建说明:
     * 大小: 12*12
     * 蓝子: 1标识
     * 黑子: 2标识
     * <p>
     * 〉
     *
     * @className: SparseArray
     * @author: hf
     * @version: 1.0.0
     * @date: 2019/7/12 14:15
     * @param: []
     * @return: int[][]
     */
    private static int[][] createArr() {
        int[][] arr = new int[12][12];
        arr[2][3] = 1;
        arr[2][4] = 1;
        arr[2][5] = 2;
        arr[2][6] = 1;
        arr[3][4] = 2;
        arr[3][5] = 1;
        arr[3][6] = 2;
        arr[4][3] = 2;
        arr[4][4] = 2;
        arr[4][5] = 1;
        arr[4][6] = 2;
        arr[4][7] = 2;
        arr[5][2] = 1;
        arr[5][4] = 1;
        arr[5][6] = 2;
        arr[5][8] = 1;
        return arr;
    }

    /**
     * 功能描述: <br>
     * 〈
     * 二维数组转抽稀数组
     * 〉
     *
     * @className: SparseArray
     * @author: hf
     * @version: 1.0.0
     * @date: 2019/7/12 13:47
     * @param: [array【原始冗余的二维数组】, sameVal【相同值/冗余值】]
     * @return: int[][]
     */
    private static int[][] arrayToSparseArray(int[][] array, int sameVal) {

        //获取有效数据个数
        int sum = 0;
        for (int[] ints : array) {
            for (int j = 0; j < array.length; j++) {
                if (ints[j] != sameVal) {
                    sum++;
                }
            }
        }

        //构建稀疏数组 并将有效值赋值
        int[][] sparseArr = new int[sum + 1][3];
        sparseArr[0][0] = array.length;
        sparseArr[0][1] = array.length;
        sparseArr[0][2] = sum;
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                if (array[i][j] != 0) {
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = array[i][j];
                }
            }
        }

        return sparseArr;
    }

    /**
     * 功能描述: <br>
     * 〈
     * 稀疏数组恢复为二维数组
     * 〉
     *
     * @className: SparseArray
     * @author: hf
     * @version: 1.0.0
     * @date: 2019/7/12 14:04
     * @param: [sparseArr 需要恢复的稀疏数组]
     * @return: int[][]
     */
    private static int[][] sparseArrayToArray(int[][] sparseArr) {
        //构建二维数组
        int[][] arr = new int[sparseArr[0][0]][sparseArr[0][1]];
        for (int i = 1; i <= sparseArr[0][2]; i++) {
            arr[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
        return arr;
    }

    /**
     * 功能描述: <br>
     * 〈
     * 遍历二维数组
     * 〉
     *
     * @className: SparseArray
     * @author: hf
     * @version: 1.0.0
     * @date: 2019/7/12 14:12
     * @param: [arr 需要遍历的二维数组]
     * @return: void
     */
    private static void showArray(int[][] arr) {

        for (int[] rows : arr) {
            for (int item : rows) {
                System.out.printf("%d\t", item);
            }
            System.out.println();
        }
    }
}

• 运行图例