稀疏数组简介

稀疏数组

1、定义：稀疏数组可以看做是普通数组的压缩。其存储形式为：
- 第一行记录二维数组的行数，列数，以及有效数据的个数
- 其他行记录每个有效数据所在的行数，列数，以及值
2、目的：使用稀疏数组目的是为了压缩数组，节约空间。
3、应用场景：稀疏数组一般使用在一个二维数组存储着大量无效数据的场景中。

实现

Java版本

首先，定义一个普通二维数组，将它打印出来看看。

    public static void main(String[] args) {
        int[][] test = new int[15][13];
        test[2][4] = 1;
        test[3][4] = 1;
        test[4][4] = 1;
        test[5][1] = 1;
        test[3][6] = 1;
        test[3][5] = 2;
        test[7][5] = 2;
        test[8][1] = 2;
        test[4][11] = 2;
        test[9][10] = 2;
        System.out.println("=========================原始数组=========================");
        printArrays(test);
    }
        /**
     * 打印二维数组
     *
     * @param arr 二维数组
     */
    public static void printArrays(int[][] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }

可以看到，二维数组存储了 15*13 = 195个数据，但是实际有效数据只有10个，这种场景下，我们就可以考虑用稀疏数组来存储。根据稀疏数组的存储形式，可以通过以下代码实现普通数组转稀疏数组：

        /**
     * 普通数组转稀疏数组
     *
     * @param arr 普通数组
     * @return 稀疏数组
     */
    public static int[][] castSparseArray(int[][] arr) {
        //原数组行数
        int row = arr.length;
        //原数组列数
        int cloumn = arr[0].length;
        //已经使用格子数
        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++;
                }
            }
        }

        int[][] sparseArray = new int[sum + 1][3];
        sparseArray[0][0] = row; //二维数组的行数
        sparseArray[0][1] = cloumn; //二维数组的列数
        sparseArray[0][2] = sum; //有效数据的个数

        //稀疏数组填值
        int index = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] != 0) {
                    index++;
                    sparseArray[index][0] = i;
                    sparseArray[index][1] = j;
                    sparseArray[index][2] = arr[i][j];
                }
            }
        }
        return sparseArray;
    }

打印得到以下结果：

得到稀疏数组之后，我们可以通过记录的信息，还原回普通的数组：

    /**
     * @param sparseArr 稀疏数组
     * @return 普通数组
     */
    public static int[][] castToArray(int[][] sparseArr) {
        int[][] array = new int[sparseArr[0][0]][sparseArr[0][1]];
        for (int i = 1; i < sparseArr.length; i++) {
            int[] sparseRow = sparseArr[i];
            array[sparseRow[0]][sparseRow[1]] = sparseRow[2];
        }
        return array;
    }

结果如下：

C#版本

以下是C#稀疏数组实现：

        /// <summary>
        /// 普通数组转稀疏数组
        /// </summary>
        /// <param name="arr"></param>
        /// <returns></returns>
        public static int[,] castSparseArray(int[,] arr)
        {
            //原数组行数
            int row = arr.GetLength(0);
            //原数组列数
            int cloumn = arr.GetLength(1);
            //已经使用格子数
            int sum = 0;
            for (int i = 0; i < arr.GetLength(0); i++)
            {
                for (int j = 0; j < arr.GetLength(1); j++)
                {
                    if (arr[i, j] != 0)
                    {
                        sum++;
                    }
                }
            }
            int[,] sparseArray = new int[sum + 1, 3];
            sparseArray[0, 0] = row;
            sparseArray[0, 1] = cloumn;
            sparseArray[0, 2] = sum;

            //稀疏数组填值
            int index = 0;
            for (int i = 0; i < arr.GetLength(0); i++)
            {
                for (int j = 0; j < arr.GetLength(1); j++)
                {
                    if (arr[i, j] != 0)
                    {
                        index++;
                        sparseArray[index, 0] = i;
                        sparseArray[index, 1] = j;
                        sparseArray[index, 2] = arr[i, j];
                    }
                }
            }
            return sparseArray;
        }

        /// <summary>
        /// 稀疏数组转普通数组
        /// </summary>
        /// <param name="sparseArr">稀疏数组</param>
        /// <returns></returns>
        public static int[,] castToArray(int[,] sparseArr)
        {
            int[,] array = new int[sparseArr[0, 0], sparseArr[0, 1]];
            for (int i = 1; i < sparseArr.GetLength(0); i++)
            {
                array[sparseArr[i, 0], sparseArr[i, 1]] = sparseArr[i, 2];
            }
            return array;
        }

        /// <summary>
        /// 打印二维数组
        /// </summary>
        /// <param name="arr"></param>
        public static void printArrays(int[,] arr)
        {
            for (int i = 0; i < arr.GetLength(0); i++)
            {
                for (int j = 0; j < arr.GetLength(1); j++)
                {
                    Console.Write(arr[i, j] + " ");
                }
                Console.WriteLine();
            }
        }