Java数组实现简单数据结构——稀疏矩阵：原矩阵压缩为稀疏矩阵、稀疏矩阵还原为原矩阵，简单五子棋存储原理

Java数组实现简单数据结构——稀疏矩阵：原矩阵压缩为稀疏矩阵、稀疏矩阵还原为原矩阵，简单五子棋存储原理

1、稀疏矩阵定义与应用

1. 定义：

​ 矩阵中非零元素的个数远远小于矩阵元素的总数，并且非零元素的分布没有规律，通常认为矩阵中非零元素的总数比上矩阵所有元素总数的值小于等于0.05时，则称该矩阵为稀疏矩阵(sparse matrix)，该比值称为这个矩阵的稠密度；与之相区别的是，如果非零元素的分布存在规律（如上三角矩阵、下三角矩阵、对角矩阵），则称该矩阵为特殊矩阵。

2. 简单应用–五子棋存储棋盘：

   （1代表黑棋，2代蓝棋，0代表未落子）
   

2、Java代码

注：下列代码均在main()方法中书写，全部复制合并后即可正常运行

1. 引入的包：

import java.util.Scanner;

2. 原矩阵源代码：

public class sparseMatrix {
    //简单数据结构--稀疏矩阵的作用：压缩存储空间。用二维数组实现
    public static void main(String[] args) {
           //原矩阵，，从键盘录入所得
           boolean flag = true;
           int  len = 0;
           while(flag){
               len = 0;
               //控制台输入行列大小值
               Scanner scanner = new Scanner(System.in);
               System.out.println("请输入二维数组大小（大于3）："); //由于下方录入简单数据的限制，数组行列数需要大于3
               if(scanner.hasNext()){
                   len = Integer.parseInt(scanner.nextLine());
                   if(len>3){
                       flag = false;
                   }else {
                       System.out.println("输入数据不合法，请重新输入！");
                   }
               }
           }
            int[][] array = new int[len][len];
            //原矩阵录入简单数据
            array[1][2] = 1;
            array[2][3] = 2;
            //使用for-each遍历输出原矩阵,,未输入值的Java默认为0
            System.out.println("原矩阵为：");
            for (int[] ints:array){
                for (int int1:ints) {
                    System.out.print(int1+"\t");
                }
                System.out.println();
            }

3. 压缩存储–稀疏矩阵源代码：

//原矩阵压缩存储，变为稀疏矩阵
            int sum = 0;
            //确定原矩阵实际存储的有效数据个数
            for (int i = 0; i < len; i++) {
                for (int j = 0; j < len; j++) {
                    if(array[i][j] != 0){
                        sum++;
                    }
                }
            }
        System.out.println("-----------------------------"+"\n"+"原矩阵存放有效元素个数为："+sum);
        //确定稀疏矩阵的行：sum+1，列为固定值：3
        int[][] array2= new int[sum+1][3];
        array2[0][0] = len;
        array2[0][1] = len;
        array2[0][2] = sum;  //稀疏矩阵第一行存放元素组的行数、列数、有效数据数
        //遍历整个原矩阵，为稀疏矩阵赋值
        int count = 1;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++){
                if(array[i][j] != 0){
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array[i][j];
                    count++;
                }
            }
        }
        //输出稀疏矩阵
        System.out.println("\n"+"得到的稀疏矩阵为：");
        for (int[] ints:array2) {
            for (int int1:ints) {
                System.out.print(int1+"\t");
            }
            System.out.println();
        }

4. 稀疏矩阵恢复为原矩阵：

//稀疏矩阵恢复到原矩阵
        int[][] array3 = new int[array2[0][1]][array2[0][1]];
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //输出还原后的矩阵
        System.out.println("-----------------------"+"\n"+"还原后的矩阵为：");
        for (int[] ints:array3) {
            for (int int1:ints) {
                System.out.print(int1+"\t");
            }
            System.out.println();
        }
    }
}

3、运行结果：

1. 原矩阵：
   

2. 稀疏矩阵：
   

3.还原后矩阵：