数据结构学习笔记--稀疏数组

一.数据结构

1.数据结构–线性结构

1.1特点

数据元素之间一对一的关系

1.2 分类

顺序存储结构（地址连续–数组）和链式存储结构（地址不连续-链表）

1.3 包含

数组、链表、队列、栈

2.1 稀疏数组

2.1.1 需求

由图分析：使用二维数组存储棋盘存在大量无用数据—>使用稀疏数组优化

2.1.2 稀疏数组优化–思路：

记录数组一共有几行几列，有多少个不同的值
用另一个小数组记录不同值的元素的行列及值

图片解析：
稀疏数组的第一行的row：记录了二维数组有多少行
稀疏数组的第一行的col：记录了二维数组有多少列
稀疏数组的第一行的value：记录了二维数组有多少个不同于 o 的值

稀疏数组其他行的row，col，calue：分别记录了二维数组中非零元素的行、列、值

2.1.3 实现思路：

二维数组转稀疏数组：

遍历二维数组，得到有效数据的个数sum
创建稀疏数组，int【sum+1】【3】
将二维数组的有效数据存入稀疏数组

稀疏数组转二维数组：

读取稀疏数组的第一行数据，创建二维数组，int【row】【col】
读取稀疏数组其他行，并赋值给原始二维数组即可
2.1.4  代码实现：

public class SparseArray {
    public static void main(String[] args) {
        //创建一个二维数组
        //0:表示没有棋子，1：表示黑子，2：表示白子
        int chessArr1[][] =new int [11][11];
        chessArr1[2][4]=1;
        chessArr1[2][5]=2;
        chessArr1[3][6]=1;

        //输出原始二维数组
        for (int[]row:chessArr1
             ) {
            for (int data:row
                 ) {
               // System.out.printf("%d"+ data);  %d十进制整数 \缩进Tab
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }

        //遍历二维数组，得到有效数据的个数sum
        int sum=0;
        for (int i=0;i<11;i++){
            for (int j=0;j<11;j++){
                if (chessArr1[i][j]!=0){
                    sum++;
                }
            }
        }

        //创建稀疏数组，int【sum+1】【3】
        int[][] sparseArray=new int[sum+1][3];
        sparseArray[0][0]=11;
        sparseArray[0][1]=11;
        sparseArray[0][2]=sum;

        //将二维数组的有效数据存入稀疏数组
        int count=0;//记录第几个非零数
        for (int i=0;i<11;i++){
            for (int j=0;j<11;j++){
                if (chessArr1[i][j]!=0){
                    count++;
                    sparseArray[count][0]=i;
                    sparseArray[count][1]=j;
                    sparseArray[count][2]=chessArr1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("输出稀疏数组");
        for (int[]row:sparseArray
        ) {
            for (int data:row
            ) {
                // System.out.printf("%d"+ data);  %d十进制整数 \缩进Tab
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }

        //稀疏数组转二维数组
        //读取稀疏数组的第一行数据，创建二维数组，int【row】【col】
        int[][] chessArr2=new int[sparseArray[0][0]][sparseArray[0][1]];

        //读取(遍历)稀疏数组其他行，并赋值给原始二维数组即可
        chessArr2[sparseArray[1][0]][sparseArray[1][1]]=sparseArray[1][2];
        chessArr2[sparseArray[2][0]][sparseArray[2][1]]=sparseArray[2][2];
        chessArr2[sparseArray[3][0]][sparseArray[3][1]]=sparseArray[3][2];

        for (int i=1;i<sparseArray.length;i++){
            chessArr2[sparseArray[i][0]][sparseArray[i][1]]=sparseArray[i][2];
        }

        //输出 新的二维数组
        System.out.println("新的二维数组");
        for (int[]row:chessArr1
        ) {
            for (int data:row
            ) {
                // System.out.printf("%d"+ data);  %d十进制整数 \缩进Tab
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
    }
}