java 稀疏数组

线性结构和非线性结构

线性结构

1>线性结构最为常用的数据结构，其特点是数据元素之间存在一对一的线性关系
2>线性结构有两种不同的存储结构，即顺序存储结构（顺序存储的线性表又称为顺序表，顺序表中存储的数据是线连续的（地址），比如数组、队列、链表、栈等）和链式存储结构（地址不连续，那么可以很好的利用内存碎片）。
3>链式存储的线性表称为链表、链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息
4>顺序与链式的区别：顺序存储地址是连续的、链式存储地址是不连续的

非线性结构

1>非线性结构包含：二维数组、多维数组，广义表，树结构，图结构等
2>树结构和图结构比较常用

稀疏数组

需求：五子棋的存盘退出 与 续上盘的功能

如何保存落子信息 与 如何描述棋盘呢？？？

答案：是可以用二维数组来表示棋盘 用0、1、2等给数组赋值来表示用户下的白子（2）、黑子（1）、空（0）

找个特点，由于默认值为0，如果直接对二维数组进行全部的读取与存储，那么就会浪费大量的存储空间，并且存了很多没有意义且重复的值：0，那么我们可以用稀疏数组进行数据的压缩

稀疏数组的介绍：

当一个数组中大部分元素是0或者为同一个值的数组时，可以用稀疏数组来保存该数组。
大白话就是：用稀疏数组来描述一个多维数组

稀疏数组的处理方法：

1. 记录数组一共有几行几列，有多少个不同的值
2. 把具有不同值的元素的行和列及值记录在一个小规模的数组中，从而缩小程序的规模

一个例子：

源程序：

	0	1	2	3	4	5	6
0	0	0	0	22	0	0	15
1	0	11	0	0	0	17	0
2	0	0	0	-6	0	0	0
3	0	0	0	0	0	39	0
4	91	0	0	0	0	0	0
5	0	0	28	0	0	0	0

==第一行和第一列为行数和列数 ==
划分后:

	行	列	值（一共有几个特殊的值）
0	6	7	8
1	0	3	22
2	0	6	15
3	1	1	11
4	1	5	7
5	2	3	-6
6	3	5	39
7	4	0	91
8	5	2	28

ps:
1.第一列记录了还原后的数组有几行几列有几个特殊值（非0值，与相同值不同的值）
2.之后便是对特殊值的坐标做记录
3.从6 * 7 变成了 3 * 9

代码的实现：

public class XiShuShuZu {
    public static void main(String[] args) {
        //创造一个 11 * 11 的二维数组
        int array[][] = new int[11][11];
        //0 表示空子 1 表示黑子 2表示蓝子
        array[3][5] = 2;
        array[4][1] = 1;
        array[2][0] = 2;
        array[9][8] = 2;
        array[3][7] = 1;
        //显示一下 原始的二维数组
        System.out.println("原始二维数组");
        for(int []i : array){
            for(int j:i){
                System.out.print(" "+j);
            }
            System.out.println();
        }

        //下一步骤开始创建稀疏数组：
        /**
         * 1.遍历二维数组初始化稀疏数组的行列与值：因为一开始并不知道你有几个值,
         * 根据稀疏数组的特点可以是3列，行 = 值+1
         */
        int col=3,value=0;
        for(int []i : array){
            for(int j:i) {
                if (j != 0) {
                    value++;
                }
            }
        }
        //创建稀疏数组
        int arrayXiShu[][] = new int[value+1][col];
        //描述源数组的基本性质：行、列、几个不同的值
        arrayXiShu[0][0] = 11;
        arrayXiShu[0][1] = 11;
        arrayXiShu[0][2] = value;

        //赋值稀疏数组,行是在变化的，所以单独将行罗列出来
        int count = 1;
        for(int i=0;i<array.length;i++){
            for(int j=0;j<array.length;j++){
                if (array[i][j]!=0){
                    arrayXiShu[count][0] = i; //第一列
                    arrayXiShu[count][1] = j; //第二列
                    arrayXiShu[count][2] = array[i][j]; //第三列
                    count++;
                }
            }
        }

        System.out.println("压缩后的值：");
        for(int i[]:arrayXiShu){
            for (int j: i){
                System.out.print("   "+j);
            }
            System.out.println();
        }

        //复原稀疏数组
        int [][]arrayFuYuan = new int[arrayXiShu[0][0]][arrayXiShu[0][1]];
        for (int i=1;i<arrayXiShu[0][2]+1;i++){
            arrayFuYuan[arrayXiShu[i][0]][arrayXiShu[i][1]] = arrayXiShu[i][2];
        }

        System.out.println("输出遍历后的值");
        for(int []i : arrayFuYuan){
            for(int j:i){
                System.out.print(" "+j);
            }
            System.out.println();
        }
    }
}

--------尚硅谷有感