稀疏数组和二维数组的转换

0数据结构

一位大牛曾经说过，程序=数据结构+算法，所以数据结构相当重要！
数据结构分为两类，线性结构和非线性结构

1.线性结构：

1. 作为最常用的数据结构，特点是数据元素之间存在一对一的对应关系
2. 线性结构有着两种不同的存储结构，即顺序存储结构（如数组）****和链式存储结构（如链表）
3. 顺序存储结构称为顺序表，顺序表中的存储元素是连续的
4. 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素，以及相邻元素的地址信息
5. 常见的线性结构：数据，队列，链表和栈

2.非线性结构：
常见的非线性结构包括：二维数组，广义表，树结构，图结构

1稀疏数组

存储数据中，有一种数组叫做稀疏数组，和数组的主要区别就是可以减少存储空间，相当于对二维数组的压缩。

从上图中可以看此二维数组中，只有少量的数据，其余的都是0，于是为了解决这种情况，引入稀疏数组，也就是达到对数据进行压缩的目的。下表是对二维数组用稀疏数组表示

二维数组行数	二维数组列数	值
8	5	4
0	0	1
1	1	2
2	0	1
3	1	2

解释：稀疏数组的第一行总是对二维数组的整体描述，即：二维数组是8行5列，共四个有用数据。第二行往下表示二维数组的所有数值信息，如第二行数据表示，第1行第1列的值是1，第四行表示的数据是：二维数组中，第4行，第2列的值是2。

将二维数组转换成稀疏数组的步骤

1. 遍历二维数组，得到有用的数据个数sum
2. 根据sum就可以创建稀疏数组 sparseArrint[sum+1][3] (因为稀疏数组只有三列)
3. 将二维数组的有效数据存入到稀疏数组中。

将稀疏数组转换成原始二维数组的步骤

1. 先读取稀疏数组的第一行，根据第一行的数据行数和列数，来创建原始的二维数组
2. 读取稀疏数组后几行的数据，并赋值给创建的二维数组。

代码实现以上过程：

package com.njupt;

/**
 * Creat with IntelliJ IDEA
 * @Date:2021/07/12/12:41
 * @Description:模拟二维数组和稀疏数组的相互转换！
 */
public class SparseArray {
    public static void main(String[] args) {
        //创建原始二维8*5的数组
        int chessArray1[][] =new int[8][5];
        //给二维数组赋值
        chessArray1[0][0]=1;
        chessArray1[1][1]=2;
        chessArray1[2][0]=1;
        chessArray1[3][1]=2;
        //对数据进行遍历，显示原始数组
        System.out.println("原始二维数组为：");
        for (int[] row:chessArray1) {
            for(int value:row){
                System.out.print("\t"+value);
            }
            //换行
            System.out.println();
        }
        //要把此二维数组变成稀疏数组
        System.out.println("把原始二维数组转化成稀疏数组如下：");
        //第一步，遍历数组，找到数组中所有的有意义的数据sum（！=0的数据的个数）
        int sum=0;
        for (int[] row:chessArray1) {
            for(int value:row){
                if(value!=0){
                    sum++;
                }
            }
        }
        //System.out.println(sum);
        //第二步，创建稀疏数组,顺便给稀疏数组的第一行数据赋值
        int sparseArr[][] =new int[sum+1][3];
        sparseArr[0][0]=8;
        sparseArr[0][1]=5;
        sparseArr[0][2]=sum;
        //第三步：往稀疏数组里赋值
        int count=0;//作用是来确定稀疏数组的行数，用来给每一行赋值
        for(int i=0;i<8;i++){
            for(int j=0;j<5;j++){
                if(chessArray1[i][j]!=0){
                    count++;//从第二行开始啦！
                    sparseArr[count][0]=i;
                    sparseArr[count][1]=j;
                    sparseArr[count][2]=chessArray1[i][j];
                }
            }
        }
        //对稀疏数组进行输出
        for (int[] row:sparseArr) {
            for(int value:row){
                System.out.print("\t"+value);
            }
            System.out.println();
        }

        System.out.println("下面是把稀疏数组变成二维数组：");
        //第一步：取出稀疏数组的第一行数据，来创建二维数组。
        int chessArray2[][] = new int[sparseArr[0][0]] [sparseArr[0][1]];
        //从第二行开始取数据
        for(int i=1;i<sparseArr.length;i++){
            //根据稀疏数组的特点，从第二行开始，每一行的第一列是数据在二维数组行数，
            // 第二列是数据在二维数组的列数，第三列是值
            chessArray2[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
        }
        //遍历二维数组
        for(int i=0;i<8;i++){
            for(int j=0;j<5;j++){
                System.out.print("\t"+chessArray2[i][j]);
            }
            System.out.println();
        }
    }
}

结果：

原始二维数组为：
	1	0	0	0	0
	0	2	0	0	0
	1	0	0	0	0
	0	2	0	0	0
	0	0	0	0	0
	0	0	0	0	0
	0	0	0	0	0
	0	0	0	0	0
把原始二维数组转化成稀疏数组如下：
	8	5	4
	0	0	1
	1	1	2
	2	0	1
	3	1	2
下面是把稀疏数组变成二维数组：
	1	0	0	0	0
	0	2	0	0	0
	1	0	0	0	0
	0	2	0	0	0
	0	0	0	0	0
	0	0	0	0	0
	0	0	0	0	0
	0	0	0	0	0

Process finished with exit code 0