数据结构 - 稀疏数组

于 2025-03-09 15:11:20 发布
阅读量1k 收藏 13
点赞数 20
分类专栏： 数据结构和算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/muriyue6/article/details/145858984
版权

数据结构 - 稀疏数组

稀疏数组的应用场景

先看一个实际的需求

编写的五子棋程序中，有存盘退出和续上盘的功能。
在这里插入图片描述

分析问题：
因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据。-> 顾使用稀疏数组进行压缩优化。

稀疏数组基本介绍

当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方法是：

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

稀疏数组举例说明

在这里插入图片描述

稀疏数组应用实例

  1. 使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等)。
  2. 把稀疏数组存盘，并且可以从新恢复原来的二维数组数。
  3. 整体思路分析。
    在这里插入图片描述

在这里插入图片描述

二维数组 转 稀疏数组的思路：
1.遍历 原始的二维数组，得到有效数据的个数sum。
2.根据sum就可以创建稀疏数组sparseArr int[sum+1][3]。
3.将二维数组的有效数据存入到稀疏数组。

稀疏数组转原始的二维数组的思路：
1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的chessArr2 = int[11][11]。
2.在读取稀疏数组后几行的数据，并赋给原始的二维数组即可。

  1. 代码实现

二位数组转稀疏数组

思路

1.先遍历二维数组 得到非0数据的个数
2.创建对应的稀疏数组
3.给稀疏数组赋值
4.遍历原始二维数组，将有效棋子(非0值)放入sparseArray(稀疏数组)中

代码实现

package com.mry.datastructures.sparsearray;

/**
 * 二位数组转稀疏数组
 */
public class SparseArray {
    public static void main(String[] args) {
        //创建一个原始的二维数组 11*11
        //0：表示没有棋子，1表示黑子，2表示篮子
        int chessArr1[][] = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        //输出原始的二维数组
        System.out.println("原始的二维数组是：");
        ergodic(chessArr1);
        System.out.println("====================分割线====================");

        //二维数组转稀疏数组
        //1.先遍历二维数组 得到非0数据的个数
        int sum = 0;
        for (int[] r : chessArr1) {
            for (int c : r) {
                if (c != 0) {
                    sum ++;
                }
            }
        }
        System.out.println("sum = " + sum);

        //2.创建对应的稀疏数组
        int sparseArr[][] = new int[sum + 1][3];
        //3.给稀疏数组赋值
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;

        //4.遍历原始二维数组，将有效棋子(非0值)放入sparseArray数组中
        //i表示行，j表示列
        int count = 0;  //用于记录第几个非0数据
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; j++) {
                if (chessArr1[i][j] != 0) {
                    count ++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr1[i][j];
                }
            }
        }
        System.out.println("稀疏数组是：");
        ergodic(sparseArr);

    }

    //遍历工具类
    private static void ergodic(int[][] array){
        for (int[] row : array) {
            for (int item : row) {
                System.out.printf("%d\t", item);
            }
            System.out.println();
        }
    }

}

在这里插入图片描述

稀疏数组转二位数组

思路

1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的chessArr2 = int[11][11]。
2.在读取稀疏数组后几行的数据，并赋给原始的二维数组即可。

代码实现

package com.mry.datastructures.sparsearray;

/**
 * 稀疏数组转二位数组
 */
public class SparseArray {
    public static void main(String[] args) {
        //创建一个原始的二维数组 11*11
        //0：表示没有棋子，1表示黑子，2表示篮子
        int chessArr1[][] = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        //输出原始的二维数组
        System.out.println("原始的二维数组是：");
        ergodic(chessArr1);
        System.out.println("====================分割线====================");

        //二维数组转稀疏数组
        //1.先遍历二维数组 得到非0数据的个数
        int sum = 0;
        for (int[] r : chessArr1) {
            for (int c : r) {
                if (c != 0) {
                    sum ++;
                }
            }
        }
        System.out.println("sum = " + sum);

        //2.创建对应的稀疏数组
        int sparseArr[][] = new int[sum + 1][3];
        //3.给稀疏数组赋值
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;

        //4.遍历原始二维数组，将有效棋子(非0值)放入sparseArray数组中
        //i表示行，j表示列
        int count = 0; //用于记录第几个非0数据
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; j++) {
                if (chessArr1[i][j] != 0) {
                    count ++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr1[i][j];
                }
            }
        }
        System.out.println("稀疏数组是：");
        ergodic(sparseArr);
        System.out.println("====================分割线====================");

        //将稀疏数组 --> 恢复成 原始的二维数组
        //1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的chessArr2 = int[11][11]。
        int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
        //2.在读取稀疏数组后几行的数据(从第二行开始)，并赋给原始的二维数组即可。
        for (int i = 1; i < sparseArr.length; i++) {
            chessArr2[sparseArr[i][0]][sparseArr[i][1]]= sparseArr[i][2];
        }
        System.out.println("恢复后的稀疏数组是：");
        ergodic(chessArr2);

    }

    //遍历工具类
    private static void ergodic(int[][] array){
        for (int[] row : array) {
            for (int item : row) {
                System.out.printf("%d\t", item);
            }
            System.out.println();
        }
    }

}


原始的二维数组是：
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
====================分割线====================
sum = 2
稀疏数组是：
11	11	2	
1	2	1	
2	3	2	
====================分割线====================
恢复后的稀疏数组是：
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0

稀疏数组序列化和反序列化

工具类

package com.mry.datastructures.utils;

import java.io.*;

/**
 * 序列化工具类
 */
public class ArraySerializableUtil {

    public final static String resourcePath = "D:\\file\\file.txt";

    public static void sparseSerializable(int[][] array){
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream(resourcePath));
            oos.writeObject(array);
            oos.flush();
        } catch (Exception e) {
            e.getStackTrace();
        } finally {
            try {
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static Object sparseDSerializable(){
        ObjectInputStream ois = null;
        Object arr = null;
        try {
            ois = new ObjectInputStream(new FileInputStream(resourcePath));
            arr = ois.readObject();
            return arr;
        } catch (Exception e) {
            e.getStackTrace();
        } finally {
            try {
                ois.close();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        return null;
    }

}

验证

package com.mry.datastructures.sparsearray;

import com.mry.datastructures.utils.ArraySerializableUtil;

/**
 * 二位数组转稀疏数组
 */
public class SparseArray {
    public static void main(String[] args) {
        //创建一个原始的二维数组 11*11
        //0：表示没有棋子，1表示黑子，2表示篮子
        int chessArr1[][] = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        //输出原始的二维数组
        System.out.println("原始的二维数组是：");
        ergodic(chessArr1);
        System.out.println("====================分割线====================");

        //二维数组转稀疏数组
        //1.先遍历二维数组 得到非0数据的个数
        int sum = 0;
        for (int[] r : chessArr1) {
            for (int c : r) {
                if (c != 0) {
                    sum ++;
                }
            }
        }
        System.out.println("sum = " + sum);

        //2.创建对应的稀疏数组
        int sparseArr[][] = new int[sum + 1][3];
        //3.给稀疏数组赋值
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;

        //4.遍历原始二维数组，将有效棋子(非0值)放入sparseArray数组中
        //i表示行，j表示列
        int count = 0; //用于记录第几个非0数据
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; j++) {
                if (chessArr1[i][j] != 0) {
                    count ++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr1[i][j];
                }
            }
        }
        System.out.println("稀疏数组是：");
        ergodic(sparseArr);

        //稀疏数组序列化(输出稀疏数组到文件中)
        ArraySerializableUtil.sparseSerializable(sparseArr);
        //稀疏数组反序列化
        int[][] arr = (int[][])ArraySerializableUtil.sparseDSerializable();
        System.out.println("读取文件中的稀疏数组是：");
        ergodic(arr);
    }

    //遍历工具类
    private static void ergodic(int[][] array){
        for (int[] row : array) {
            for (int item : row) {
                System.out.printf("%d\t", item);
            }
            System.out.println();
        }
    }

}

控制台输出：

原始的二维数组是：
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
====================分割线====================
sum = 2
稀疏数组是：
11	11	2	
1	2	1	
2	3	2	
读取文件中的稀疏数组是：
11	11	2	
1	2	1	
2	3	2

本地文件如下：
在这里插入图片描述

博客
PCIE协议-4-逻辑物理层-8.0 GT/s及更高数据速率编码
意大利炮修理师的博客
05-27 2513
当PCI Express链路以8.0 GT/s或更高的数据速率运行时，它使用本小节中描述的编码规则：128b/130b编码。为了向后兼容，链路最初在2.5 GT/s数据速率下使用8b/10b编码进行训练到L0，如第4.2.1节所述，然后当数据速率更改为8.0 GT/s或更高时，使用128b/130b编码。128b/130b编码是一种链路范围内的数据包机制和每个通道的块码以及扰乱。数据传输的基本单位是一个8位数据字符，称为符号，如图4-11和图4-12所示。
博客
PCIE-链路宽度和速度
最新发布
m0_61703043的博客
06-10 8516
PCIE基础知识
博客
【S025】pcie报文格式--MRd/MWr/CPLD
1615549892
04-15 8295
MRd
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值