【数据结构】稀疏数组

使用稀疏数组，模拟下棋、地图等，将二维数组转为稀疏数组，节省空间

使用二维数组模拟棋盘，1为白棋，2为黑棋
只有2个棋子，其他的都是0浪费内存
0  0  0  0  0
0  0  1  0  0
0  0  0  2  0
0  0  0  0  0
0  0  0  0  0 
 
将普通的二维数组转为稀疏数组
				   总行 总列     不为0的数据总量
第一个不为0的数据所在的行 所在的列 存放的数据
第二个不为0的数据所在的行 所在的列 存放的数据
...

5 5 2
1 2 1
2 3 2
 

代码实现

public class SparseArray {

    public static void main(String[] args) {

        int[][] arr = new int[5][5];
        arr[1][2] = 1;
        arr[2][3] = 2;
        for (int[] row : arr) {
            for (int data : row) {
                System.out.print(data+"\t");
            }
            System.out.println();
        }
        System.out.println("===========arrayToSparseArray============");
        // 再添加一条数据查看是否成功
        arr[1][3] = 2;
        int[][] sparseArray = changeSparseArray(arr);
        for (int[] row : sparseArray) {
            for (int data : row) {
                System.out.print(data+"\t");
            }
            System.out.println();
        }
        System.out.println("==========sparseArrayToArray=============");
        int[][] toArray = toArray(sparseArray);
        for (int[] row : toArray) {
            for (int data : row) {
                System.out.print(data+"\t");
            }
            System.out.println();
        }

    }


    /**
     * 将普通的二维数组转为稀疏数组
     * @param arr
     * @return
     */
    public static int[][] changeSparseArray(int[][] arr){
        // 获取数组总行数和列数
        int length = arr.length;
        int column = arr[0].length;
        // 获取有数据(不为0)的总数
        int count = 0;
        for (int[] row : arr) {
            for (int data : row) {
                if (data != 0) {
                    count++;
                }
            }
        }
        // 稀疏数组固定列为3，行为数据总量+1
        int[][] sparseArray = new int[count + 1][3];
        sparseArray[0][0] = length;
        sparseArray[0][1] = column;
        sparseArray[0][2] = count;

        // 遍历数组找到不为0的位置
        // 找到不为0的元素要添加到稀疏数组中的索引行，第一行有数据，从第二行开始添加
        int curr = 1;
        for (int i = 0; i < length; i++) {
            for (int j = 0; j < column; j++) {
                if (arr[i][j] != 0) {
                    sparseArray[curr][0] = i;
                    sparseArray[curr][1] = j;
                    sparseArray[curr][2] = arr[i][j];
                    curr++;
                }
            }
        }
        return sparseArray;
    }

    /**
     * 稀疏数组转换为二维数组
     * @param sparseArray
     * @return
     */
    public static int[][] toArray(int[][] sparseArray) {
        int length = sparseArray[0][0];
        int column = sparseArray[0][1];
        int count = sparseArray[0][2];

        int[][] arr = new int[length][column];
        for (int i = 1; i <= count; i++) {
            int r = sparseArray[i][0];
            int c = sparseArray[i][1];
            int data = sparseArray[i][2];
            arr[r][c] = data;
        }
        return arr;
    }

  
}