稀疏数组的转换

炸克婶989

已于 2022-12-26 09:04:22 修改

阅读量115

点赞数

分类专栏：数据结构文章标签： java 数据结构

于 2022-12-26 08:57:57 首次发布

本文链接：https://blog.csdn.net/weixin_64650214/article/details/128439499

版权

数据结构专栏收录该内容

2 篇文章 0 订阅

订阅专栏

本文介绍了如何使用稀疏数组来优化存储空间，特别是在大量元素为0或相同值的情况下。内容包括稀疏数组的概念，如何通过代码实现转换，以及如何将稀疏数组保存到磁盘并在后续读取恢复原数组。

摘要由CSDN通过智能技术生成

文章目录

- 稀疏数组的转换

稀疏数组的转换

数据结构=线性结构（数组+链表(单+双+环形)）+非线性结构（树+图）

线性结构(1对1)存储方式：

1.顺序存储结构–>顺序表（地址是连续的）

2.链式存储结构–>链表(chongf)

常见有：数组，队列，栈，链表；

非线性结构包括：二维数组，多维数组，广义表，树结构，图结构；

1.稀疏数组sparseArr（缩小程序规模）

当数组种大部分元素为0或者同一个值时，可以使在这里插入图片描述
用稀疏数组来保存改数组；

[0]元素，保存原数组有几行几列和有几个不为0/相同元素的元素个数

在这里插入图片描述

2.稀疏数组代码实现：

		//创建一个原始的二维数组11*11
        //0表示没有棋子，1表示黑子，2表示蓝子
        int chessArr1[][]=new int[11][11];
        chessArr1[1][2]=1;
        chessArr1[2][3]=2;
        chessArr1[3][4]=2;
        System.out.println("原始的二维数组");
        for (int[] row: chessArr1){
            for (int data : row) {
                System.out.print(data+"\t");
            }
            System.out.println();
        }

        //二维数组转稀疏数组
        //1.先遍历二维数组，得到非0数据的个数
        int sum = 0;
        for (int[] row: chessArr1){
            for (int data : row) {
               if (data!=0){
                   sum++;
               }
            }
        }
        //2.创建一个对应的稀疏数组
        int[][] sparseArr = new int[sum+1][3];
        //给稀疏数组赋值
        sparseArr[0][0]=chessArr1.length;
        sparseArr[0][1]=chessArr1[0].length;
        sparseArr[0][2]=sum;
        //遍历二维数组，将非0元素存放到稀疏数组
        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("得到的稀疏数组是：");
        for (int i = 0; i < sparseArr.length; i++) {
            for (int j = 0; j < sparseArr[i].length; j++) {
                System.out.print(sparseArr[i][j]+"\t");
            }
            System.out.println();
        }

        //将稀疏数组，转化二维数组
        //1.先读取稀疏数组第一行，创建一个二维数组
        int[][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]];
        for (int i = 1; i < sparseArr.length; i++) {
            chessArr2[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
        }
        for (int i = 0; i < chessArr2.length; i++) {
            for (int j = 0; j < chessArr2[i].length; j++) {
                System.out.print(chessArr2[i][j]+"\t");
            }
            System.out.println();
        }

3.稀疏数组保存到磁盘上和读取；

要求：1.在前面的基础上，将稀疏数组保存到磁盘上，比如map.data

2.恢复原来的数组时，读取map.data进行恢复；

/创建一个原始的二维数组11*11
        //0表示没有棋子，1表示黑子，2表示蓝子
        int chessArr1[][]=new int[11][11];
        chessArr1[1][2]=1;
        chessArr1[2][3]=2;
        chessArr1[3][4]=2;
        System.out.println("原始的二维数组");
        for (int[] row: chessArr1){
            for (int data : row) {
                System.out.print(data+"\t");
            }
            System.out.println();
        }

        //二维数组转稀疏数组
        //1.先遍历二维数组，得到非0数据的个数
        int sum = 0;
        for (int[] row: chessArr1){
            for (int data : row) {
               if (data!=0){
                   sum++;
               }
            }
        }
        //2.创建一个对应的稀疏数组
        int[][] sparseArr = new int[sum+1][3];
        //给稀疏数组赋值
        sparseArr[0][0]=chessArr1.length;
        sparseArr[0][1]=chessArr1[0].length;
        sparseArr[0][2]=sum;
        //遍历二维数组，将非0元素存放到稀疏数组
        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];
                }
            }
        }

        //将稀疏数组存储到文件中
        String filePath="map.txt";
        BufferedWriter bw = null;
        try {
            File f = new File(filePath);
            //创建文件
            f.createNewFile();
            //将稀疏数组存储到文件中（输出流）
            bw = new BufferedWriter(new FileWriter(filePath));
            for (int i = 0; i < sparseArr.length; i++) {
                bw.write(sparseArr[i][0]+" "+sparseArr[i][1]+" "+sparseArr[i][2]);
                bw.newLine();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if (bw!=null){
                    bw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        //输出稀疏数组
        System.out.println("得到的稀疏数组是：");
        for (int i = 0; i < sparseArr.length; i++) {
            for (int j = 0; j < sparseArr[i].length; j++) {
                System.out.print(sparseArr[i][j]+"\t");
            }
            System.out.println();
        }

        // 读取文件中的稀疏数组，用String的二维数组装
        BufferedReader br = null;
        int index = 0;//记录装了几行数据
        String[][] temp3 = new String[1024][3];
        try {
            //读取文件
            br = new BufferedReader(new FileReader(filePath));
            String line;//读取到的一行数据
            while ((line=br.readLine())!=null){
                temp3[index++]=line.split(" ");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if (br!=null){
                    br.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        //将String二维数组转为int型的稀疏数组；
        int[][] sparseArr2 = new int[index][3];
        for (int i = 0; i < index; i++) {
            sparseArr2[i][0]=Integer.parseInt(temp3[i][0]);
            sparseArr2[i][1]=Integer.parseInt(temp3[i][1]);
            sparseArr2[i][2]=Integer.parseInt(temp3[i][2]);
        }
        //将稀疏数组，转化二维数组
        //1.先读取稀疏数组第一行，创建一个二维数组
        int[][] chessArr2 = new int[sparseArr2[0][0]][sparseArr2[0][1]];
        for (int i = 1; i < sparseArr2.length; i++) {
            chessArr2[sparseArr2[i][0]][sparseArr2[i][1]]=sparseArr2[i][2];
        }
        for (int i = 0; i < chessArr2.length; i++) {
            for (int j = 0; j < chessArr2[i].length; j++) {
                System.out.print(chessArr2[i][j]+"\t");
            }
            System.out.println();
        }