java 二维数组与稀疏数组之间相互转换

一、什么是稀疏数组？

基本介绍
1、当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方法是:
（1）记录数组一共有几行几列，有多少个不同的值
（2）把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

二、案例分析

三、代码实现

package com.demo;

public class SparseArray {
    public static void main(String[] args) {
        // 一个二维数组，11行11列
        int chessArrs[][] = new int[11][11];
        // 0:表示没有棋子，1：表示黑子 2：表示蓝子
        chessArrs[1][2] = 1;
        chessArrs[2][3] = 2;
        System.out.println("原始的二维数组...");
        for (int[] chessArr : chessArrs) {
            for (int data : chessArr) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }

        // 二维数组转稀疏数组思路
        // 1、计算出二维数组中数字的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(chessArrs[i][j] != 0){
                    sum ++;
                }
            }
        }
        System.out.println("二维数组中sum =" + sum);

        // 2.根据第一步得到的值，创建稀疏数组，列是固定的为3；行
        /*
          11 11 2
          1  2  1
          2  3  2
        */
        int sparseArr[][] = new int[sum+1][3];
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;
        // 向稀疏数组存放值，需要遍历原始二维数组
        int count = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(chessArrs[i][j] != 0){
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArrs[i][j];
                }
            }
        }

        System.out.println("输出稀疏数组的形式....");
        // 输出稀疏数组的形式
        for (int i = 0; i < sparseArr.length; i++) {
            System.out.printf("%d\t%d\t%d\t\n " , sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
        }

        /**
         * 通过稀疏数组 -》二维数组
         * 思路：
         *   1、读取稀疏数组的第一行，创建二维数组
         *   2、遍历稀疏数组，给二维数组赋值
         */
        // 二维数组的行
        int m = sparseArr[0][0];
        // 二维数组的列数
        int n = sparseArr[0][1];
        // 创建二维数组
        int arr[][] = new int[m][n];

        // 2.给二维数组赋值，遍历稀疏数组,得到值在二维数组中的位置
        for (int i = 1; i < sparseArr.length; i++) {
            // 获取值在二维数组中的行所在位置
            int a = sparseArr[i][0];
            // 获取值在二维数组中的列所在位置
            int b = sparseArr[i][1];
            // 值
            int value = sparseArr[i][2];
            arr[a][b] = value;
        }

        // 3.遍历得到二维数组的形式
        for (int[] chessArr : arr) {
            for (int data : chessArr) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92