数据结构学习之稀疏数组

稀疏数组应用场景

  适用于压缩，对于二维数组冗余数据较多，压缩成稀疏数组

当一个数组的大部分数据为0，或者为同一个数时，可以使用稀疏数组进行压缩

属于非线性结构

 

步骤

1 定义二维数组

2 转换成稀疏数组

遍历二维数组 得到有效数据个数sum

根据sum创建稀疏数组

讲二维数组有效的数据存入稀疏数组

3 稀疏数组转换成二维数组

读取第一行数据

转换后续数据

代码

package com.example.demo1.dataStructure;


import java.io.*;

/**
 * @author liangqing
 * @since 2021/2/1 10:06
 * 稀疏数组  用于多数数据都是0 或者多数数据相同的情况
 * <p>
 * 用于数据压缩  提高空间利用率
 */
public class SparseArray {

    public static void main(String[] args) throws IOException {
        //1.创建一个二维数组
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        array[3][4] = 3;

        System.out.println("数组初始化完成");
        for (int[] row : array) {
            for (int i : row) {
                System.out.printf("%d\t", i);
            }
            System.out.println();
        }

        /*
        2.转换成稀疏数组
        1. 获取有效数据个数，遍历原有二维数组
        2. 创建稀疏数组
        3. 遍历获取有效数据存入稀疏数组
         */

        //获取有效数据的个数
        int sum = 0;
        int row = array.length;
        int column = 0;
        for (int i = 0; i < array.length; i++) {
            if (column == 0) {
                column = array[i].length;
            }
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0) {
                    sum++;
                }
            }
        }
        //创建稀疏数组
        int[][] sparseArray = new int[sum + 1][3];
        sparseArray[0][0] = row;
        sparseArray[0][1] = column;
        sparseArray[0][2] = sum;

        //遍历原有数组，为稀疏数组赋值

        int index = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0) {
                    //自增，每次有一个数据，则加1
                    index++;
                    sparseArray[index][0] = i;
                    sparseArray[index][1] = j;
                    sparseArray[index][2] = array[i][j];
                }
            }
        }

        //输出稀疏数组
        System.out.println("如下是稀疏数组");
        for (int[] ints : sparseArray) {
            for (int anInt : ints) {
                System.out.printf("%d\t", anInt);
            }
            System.out.println();
        }

        /*
        稀疏数组转换成二维数组
        1. 遍历稀疏数组，创建二维数组
        2. 塞值
         */
        int[][] original = new int[sparseArray[0][0]][sparseArray[0][1]];
        for (int i = 1; i < sparseArray.length; i++) {
            original[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }

        System.out.println("恢复后的数组为：");
        for (int[] ints : original) {
            for (int anInt : ints) {
                System.out.printf("%d\t", anInt);
            }
            System.out.println();
        }

        writeSparseToFile(sparseArray);
        readSparseFromFile("1.txt");
    }


    /**
     * @Description: 将稀疏数组写入文件
     * @Param: [sparseArray]
     * @return: java.lang.String
     * @Author: luasliang
     * @Date: 2021/2/1 11:00
     */
    private static String writeSparseToFile(int[][] sparseArray) throws IOException {
        //文件操作,将数组写入文件
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("1.txt"));
        for (int[] ints : sparseArray) {
            for (int anInt : ints) {
                bufferedWriter.write(anInt + "\t");
            }
            bufferedWriter.newLine();
        }
        bufferedWriter.close();
        System.out.println("文件写入成功");
        return "1.txt";
    }

    /**
     * @Description: 从文件读出稀疏数组
     * @Param: [s]
     * @return: void
     * @Author: luasliang
     * @Date: 2021/2/1 11:00
     */
    private static void readSparseFromFile(String s) throws IOException {
        //文件操作,将数组写入文件
        //读取两次，一次记录行数总大小，也就是稀疏数组的行数
        BufferedReader bufferedWriter = new BufferedReader(new FileReader(s));
        //第二个buffer 用于生成稀疏数组使用
        BufferedReader bufferedWriter1 = new BufferedReader(new FileReader(s));

        //记录多少行
        int count = 0;
        while (bufferedWriter.readLine() != null) {
            count++;
        }

        //创建稀疏数组
        int[][] originalSparseArray = new int[count][3];

        int row = 0;
        String line;
        while ((line = bufferedWriter1.readLine()) != null) {
            final String[] split = line.split("\t");
            for (int i = 0; i < split.length; i++) {
                originalSparseArray[row][i] = Integer.parseInt(split[i]);
            }
            row++;
        }

        System.out.println("从文件读取的稀疏数组");
        for (int[] rows : originalSparseArray) {
            for (int data : rows) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }

        bufferedWriter.close();
        bufferedWriter1.close();
        System.out.println("文件写出成功");
    }


}