——稀疏数组

欢迎指正~~~~~~~

 

目录

前言

什么是稀疏数组？（Sparsearray数组）

如何将二维数组转化为稀疏数组？

我们为什么需要稀疏数组？

稀疏数组的应用场景

稀疏数组的代码实现

---

---

追风赶月莫停留，平芜尽处是春山------【明】  田韵

前言

什么是稀疏数组？（Sparsearray数组）

我们说所的稀疏数组可以看成原数组的压缩，用于无效数据量远大于有效数据量的时候，经过压缩后实现程序规模的减小。

如何将二维数组转化为稀疏数组？

例如以下二维数组转换为稀疏数组:

右边为稀疏数组，稀疏数组为三列分别对应 行， 列， 值

在第一行我们稀疏数组所对应的行列值分别为二维数组的行数， 列数，有效值数

在后面的几行所对应的为有效值所在的位置，及其值。 

我们为什么需要稀疏数组？

在使用普通数组进行储存时，往往会存入很多无效数据，这就浪费内存了。由此我们在无效数据量远大于有效数据量时我们可以采用稀疏数组进行储存节省空间。

稀疏数组的应用场景

稀疏数组的应用场景有五子棋盘的存盘，扫雷，围棋等

稀疏数组的代码实现

1.0版稀疏数组

package com.xfy;

import java.nio.charset.StandardCharsets;

public class SparseArray {
        //1.0版本
    public static void main(String[] args) {
        //创建一个二维数组，并对其进行正向遍历,
        //在定义二维数组的规模的时候我们可以将行列的值改为变量，这样就大大的增加了代码的灵活性。
        int chessart1[][]=new int[8][8];
        //以1为黑子，2为蓝子
        chessart1[2][1]=1;
        chessart1[4][3]=2;
        chessart1[3][7]=1;
        System.out.println("二维数组为：");
        for (int a[]:chessart1
             ) {
            for (int num:a
                 ) {
                System.out.print("\t"+num);
            }
            System.out.println();
        }
        //引入一个计数器，对有效值进行计数。
        int sum=0;
        //记录二维数组中有几个不同值，用于完成稀疏数组的第一个一维数组
        /*
        并且从这里可看出，我所定义的二维数组，只能是同行列，不然会出现错误，哪怎么改进呢？这里就要用
        到我们前面所定义的变量，增强代码的灵活性。
         */
        for (int i = 0; i < chessart1.length; i++) {
            for (int j = 0; j < chessart1.length ; j++) {
                if (chessart1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("二维数组中的有效值有"+sum+"个");
        //创建一个稀疏数组，将程序规模缩小，节省占用空间，也就说，我们的数据结构与算法的作用在于写出更高效的代码
        int sparsearray[][]=new int[sum+1][3];
        sparsearray[0][0]= 8;
        sparsearray[0][1]= 8;
        sparsearray[0][2]=sum;
        //将二维数组中的有效值位置及其值导入其中
        //加入计数器
        System.out.println("稀疏数组为：");
        int count=0;
        for (int i = 0; i < chessart1.length; i++) {
            for (int j = 0; j < chessart1.length ; j++) {
                if (chessart1[i][j]!=0){
                    count++;
                    sparsearray[count][0]=i;//得到有效值所在的行
                    sparsearray[count][1]=j;//有效值的列
                    sparsearray[count][2]= chessart1[i][j];//有效值的值
                }
            }
        }
        //输出我们得到的稀疏数组，

        for (int a[]:sparsearray
             ) {
            for (int num:a
                 ) {
                System.out.print("\t"+num);
            }
            System.out.println();
        }
        //再从稀疏数组还原为二维数组，实现之间的转换。
        System.out.println("重新转化为二维数组：");
        int chessart2[][]=new int[sparsearray[0][0]][sparsearray[0][1]];
        int a=0;//引入a计数器
        for (int i = 0; i < sum; i++) {
            a++;
            chessart2[sparsearray[a][0]][sparsearray[a][1]]=sparsearray[a][2];
        }
        for (int b[]:chessart2
             ) {
            for (int nnum:b
                 ) {
                System.out.print("\t"+nnum);
            }
            System.out.println();
        }
    }
}

 1.1版本稀疏数组

实现了二维数组规格的控制，以及随机下棋子的功能。

package com.xfy;

import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class SparseArray {
    public static void main(String[] args) {
        //2.0版本
        //在这里我们引入Scanner，从而可以控制二维数组的规模
        Scanner input=new Scanner(System.in);
        System.out.println("行数为：");
        int x= input.nextInt();
        System.out.println("列数为：");
        int y= input.nextInt();
        input.close();
        //创建一个二维数组，并对其进行正向遍历,
        //在定义二维数组的规模的时候我们可以将行列的值改为变量，这样就大大的增加了代码的灵活性。
        int chessart1[][]=new int[x][y];
        //以1为黑子，2为蓝子
        //同时在这里调用Math.random,得到随机数，获得不同位置放置棋子
        for (int i = 0; i <3 ; i++) {//决定下了几个棋子，棋子数目我们也是可以确定的
            if(x>y){
                int a=(int)(Math.random()*(x-1));
                int b=(int)(Math.random()*(x-1));
                int c=(int)(Math.random()*(x-1));
                int d=(int)(Math.random()*(x-1));
                chessart1[c][d]=1;
                chessart1[a][b]=2;
            }else {
                int a=(int)(Math.random()*(y-1));
                int b=(int)(Math.random()*(y-1));
                int c=(int)(Math.random()*(y-1));
                int d=(int)(Math.random()*(y-1));
                chessart1[a][b]=1;
                chessart1[c][d]=2;
            }
        }

        System.out.println("二维数组为：");
        for (int a[]:chessart1
             ) {
            for (int num:a
                 ) {
                System.out.print("\t"+num);
            }
            System.out.println();
        }
        //引入一个计数器，对有效值进行计数。
        int sum=0;
        //记录二维数组中有几个不同值，用于完成稀疏数组的第一个一维数组
        /*
        并且从这里可看出，我所定义的二维数组，只能是同行列，不然会出现错误，哪怎么改进呢？这里就要用
        到我们前面所定义的变量，增强代码的灵活性。
         */
        for (int i = 0; i < chessart1.length; i++) {
            for (int j = 0; j < chessart1.length ; j++) {
                if (chessart1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("二维数组中的有效值有"+sum+"个");
        //创建一个稀疏数组，将程序规模缩小，节省占用空间，也就说，我们的数据结构与算法的作用在于写出更高效的代码
        int sparsearray[][]=new int[sum+1][3];
        sparsearray[0][0]= x;
        sparsearray[0][1]= y;
        sparsearray[0][2]=sum;
        //将二维数组中的有效值位置及其值导入其中
        //加入计数器
        System.out.println("稀疏数组为：");
        int count=0;
        for (int i = 0; i < chessart1.length; i++) {
            for (int j = 0; j < chessart1.length ; j++) {
                if (chessart1[i][j]!=0){
                    count++;
                    sparsearray[count][0]=i;
                    sparsearray[count][1]=j;
                    sparsearray[count][2]= chessart1[i][j];
                }
            }
        }
        //输出我们得到的稀疏数组，

        for (int a[]:sparsearray
             ) {
            for (int num:a
                 ) {
                System.out.print("\t"+num);
            }
            System.out.println();
        }
        //再从稀疏数组还原为二维数组，实现之间的转换。
        System.out.println("重新转化为二维数组：");
        int chessart2[][]=new int[sparsearray[0][0]][sparsearray[0][1]];
        int a=0;//引入a计数器
        for (int i = 0; i < sum; i++) {
            a++;
            chessart2[sparsearray[a][0]][sparsearray[a][1]]=sparsearray[a][2];
        }
        for (int b[]:chessart2
             ) {
            for (int nnum:b
                 ) {
                System.out.print("\t"+nnum);
            }
            System.out.println();
        }
    }
}

 

 欢迎指正~~~~~~~~~

去做风，不被定义的风。