稀疏数组

数据结构

1. 线性结构

1. 定义：线性结构是一个有序数据元素的集合。
2. 特点：数据元素之间存在一对一的线性关系。
3. 类型：有2种，顺序存储结构（数组）、链式存储结构（链表）。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的。链式存储的线性表称为链表，链表中地存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。
4. 应用：数组、队列、链表、栈。

非线性结构

1. 定义：非线性结构，数学用语，其逻辑特征是一个节点元素可能有多个直接前驱和多个直接后继。
2. 特点：1对多/多对一/多对多。
3. 类型：3种。1）集合结构：集合中任何两个数据元素之间都没有逻辑关系，组织形式松散。（eg.二维数组、多维数组。）2）树形结构：具有分支、层次特性，其形态有点像自然界中的树。（树结构。）3）图状结构：图状结构中的节点按逻辑关系相互缠绕，任何两个节点都可以邻接。
4. 应用：广义表、二维数组…

稀疏数组

（图片来源–尚硅谷）

1. 作用：压缩内容。
   如图：原始数组，6row7colomn=42单元；稀疏数组：9row3colomn=27单元。两者存储的信息量是一样的。
2. 代码

package com.atguigu.sparsearray;


/*
* 棋盘：原始数组=》稀疏数组=》原始数组*/
public class SparseArray {
    public static void main(String[] args) {
        //原始数组=》稀疏数组
        //创建原始的二维数组，
        //0表示没有棋子，1表示黑棋，2表示蓝棋
        int [][]chessArr1=new int[11][11];
        chessArr1[1][2]=1;
        chessArr1[2][3]=2;

        System.out.println("原始的二维数组：");
        for (int[] row : chessArr1) {
            for(int data:row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }

        //创建稀疏数组
        //1.要点：value有效值的个数，通过遍历原始数组获得
        int sum=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值sum="+sum);

        //2.建立稀疏数组
        int[][] sparseArr = new int[sum + 1][3];
        sparseArr[0][0]=11;
        sparseArr[0][1]=11;
        sparseArr[0][2] = sum;

        //找value，并获取index：i，j   并获取chessArr1（i，j）
        int count=0;    //计数、递增count++，给sparseArr[?][]行赋值
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr1[i][j] != 0) {
                    count++;    //执行一边count++，count=1，下一行代码接收的是1，不是0
                    sparseArr[count][0]=i;
                    sparseArr[count][1]=j;
                    sparseArr[count][2] = chessArr1[i][j];
                }
            }
        }
        //输出方式1
        for (int[] row : sparseArr) {
            for (int data : row) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }

        /*//输出方式2
        System.out.println();
        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]);
        }
        System.out.println();   //分割代码块作用*/

        //稀疏数组=》原始数组
        int[][] chessArr2=new int[11][11];
        for (int i = 1; i <=sum; i++) {
                chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }

        //输出原始数组
        System.out.println("输出原数组");
        for (int[] row : chessArr2) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
    }
}