【Java数据结构与算法】二维数组与稀疏数组

二维数组与稀疏数组的互换：

图片来源于 尚硅谷Java数据结构与java算法

/*
	五子棋棋盘	大小：11*11
	0：没有棋子  1：黑子    2：白子
*/

public class SparseArray {
    public static void main(String[] args) {
        //  创建 二维数组 11* 11
        int[][] array = new int[11][11];
		//	给对应位置赋值
        array[1][2] = 1;
        array[2][3] = 2;
        //	array[3][4] = 2;	//测试加一个数据
        
        //  输出原始二维数组
        System.out.println("=====二维数组=======");
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[0].length; j++) {
                System.out.printf("%d\t", array[i][j]);
            }
            System.out.println();
        }

        //  1. 二维数组 -> 稀疏数组
        /*
            格式：（序号）  row col val
            大小： sum(非0数据) * 3
            步骤：
            ①.求出sum （遍历得出非0数据个数）
            ②.获取非0数据 得到 row(i) col(j) val(value)   （遍历获取）

         */
        //	①.求出sum （遍历得出非0数据个数）
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array[i][j] == 0) {

                } else
                    sum++;
            }
        }
        System.out.println("============");
        System.out.println("非0数据个数：" + sum);
        
        //	创建 稀疏数组
        int[][] sparseArray = new int[sum + 1][3];

        //	System.out.println(array.length);   //  二维数组的行
        //	System.out.println(array[0].length);    //  二维数组的列
        //	根据二维数组大小以及sum 来	对稀疏数组第0行进行赋值
        sparseArray[0][0] = 11; //  "二维数组总row：array.length = 11";
        sparseArray[0][1] = 11; //  "二维数组总col：array[0].length = 11";
        sparseArray[0][2] = sum;	//	非0数据个数
		
        //	将对应值赋值到稀疏数组中
        int counter = 1;	//	从第1行开始赋值
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array[i][j] == 0) {

                } else {
                    sparseArray[counter][0] = i;    //  "当前数据在二维数组中的行数"  就是 i;
                    sparseArray[counter][1] = j;   //   "当前数据在二维数组中的列数"  就是 j;
                    sparseArray[counter][2] = array[i][j];
                    counter++;
                }
            }
        }
        
        
        //  输出稀疏数组
        System.out.println("=====稀疏数组=======");
        for (int i = 0; i < sparseArray.length; i++) {
            for (int j = 0; j < sparseArray[0].length; j++) {
                System.out.printf("%d\t", sparseArray[i][j]);
            }
            System.out.println();
        }

        //  2. 稀疏数组 -> 二维数组

        //  创建一个二维数组
        int[][] array2 = new int [sparseArray[0][0]][sparseArray[0][1]];
        //  将稀疏数组中的数据赋值至二维数组中的对应位置
        for (int i = 1; i < sparseArray.length; i++) {
                array2[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }

		//	输出二维数组
        System.out.println("=====二维数组=======");
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[0].length; j++) {
                System.out.printf("%d\t", array2[i][j]);
            }
            System.out.println();
        }

    }
}

java获取二维数组的 行数 和 列数

int[][] array = new int[3][4];
System.out.println("二维数组的行数："+array.length);
System.out.println("二维数组的列数："+array[0].length);

思路整理：

二维数组 -> 稀疏数组

1. 求得二维数组的 行数 和 列数 （array.length array[0].length ）
   • 确定了稀疏数组第一行的 row col
2. 求得二维数组的 非0数据个数sum (遍历数组)
   • 确定了稀疏数组第一行的 val = sum
   • 确定了稀疏数组的 行数 = sum + 1
3. 求得二维数组非0数据 对应的 row 和 col 以及 value （行：i ，列：j )
   • 赋值给稀疏数组

​

稀疏数组 -> 二维数组

1. 根据稀疏数组第一行

   • 得到 二维数组的大小（row*col)

2. 根据稀疏数组后续行

   • 赋值到 二维数组对应位置