这不通俗易懂？？二维数组与稀疏数组的转换(java)

于 2021-07-02 19:02:05 发布
阅读量77 收藏
点赞数
分类专栏： java数据结构 文章标签： Java 稀疏数组 二维数组 文件操作 数组转换
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45876091/article/details/118421580
版权

Java版二维数组＜==＞稀疏数组

稀疏数组

1.应用场景

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

2.稀疏数组的处理方法

  1. 记录数组有几行几列,有几个不同的元素
  2. 把具有不同值的元素的行列和值记录在一个规模较小的数组中,缩小程序的规模
    注：稀疏数组的第一行元素值分别为：原始数组的行数,列数和有效元素个数

3.二维数组<—>稀疏数组

3.1二维数组—>稀疏数组

创建原始数组

int[][] arr= new int[11][11];
arr[2][7]=1;
arr[5][3]=2;
arr[7][5]=3;
  1. 遍历原始的二维数组,得到有效数据的个数
public static int getElementCount(int[][]a){
    int sum=0;
    for (int[] ints : a) {
        for (int j = 0; j < a[0].length; j++) {
            if (ints[j] != 0) {
                sum++;
            }
        }
    }
    return sum;
}
  1. 根据个数确定稀释数组的行数创建稀疏数组,并将有效元素存储到该数组中
    public static int[][] getSparseArr(int sum,int[][] arr){
        int[][] sparseArr=new int[sum+1][3];
//        将原数组的行数,列数和有效元素的个数赋值给稀疏数组的第一行
        sparseArr[0][0]=arr.length;
        sparseArr[0][1]=arr[0].length;
        sparseArr[0][2]=sum;
//        稀疏数组一行从左到右为有效元素的行号,列号,值,z用来记录该值为在稀疏数组的第几行
        int z=1;
//        将有效元素赋值给稀疏数组
        for (int i = 0; i < arr.length ; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                if (arr[i][j] != 0){

                    sparseArr[z][0] = i;
                    sparseArr[z][1] = j;
                    sparseArr[z][2] = arr[i][j];
                    z++;
                }
            }
        }
        return  sparseArr;
    }
  1. 用stream流打印稀疏数组
//        用stream流打印二维数组,用stream流的of方法,把二维数组转换成一维数组
//         (一维数组a的元素是一维数组b,b数组元素是稀疏数组中一行的元素)
//        [11, 11, 3]
//        [2, 7, 1]
//        [5, 3, 2]
//        [7, 5, 3]
        Stream.of(sparseArr).forEach(t->System.out.println(Arrays.toString(t)));

3.1稀疏数组—>文件

public static void putSparseArrInFile(int[][]a , String path){
    FileWriter fw=null;
    try {
        fw=new FileWriter("a.txt");
        for (int[] ints : a) {
            for (int anInt : ints) {
                fw.write(anInt +" ");
            }
            fw.write("\n");
        }
        fw.flush();
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        try {
            assert fw != null;
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.3文件—>稀疏数组

 public static int[][] getSparseArrFromFile(String path){
        BufferedReader br=null;
        int[][] sparseArr1 ;
        try {
            br=new BufferedReader(new FileReader(path));
            int sparseArrLength =0;
            while (br.readLine() !=null){
                sparseArrLength++;
            }
//            注意:这里的流已经将将整个文件读完了,所以要关闭该流,不然后面读出的为空
            br.close();
//            现在重新打开流
            br=new BufferedReader(new FileReader(path));
            sparseArr1=new int[sparseArrLength][3];
            String len="";
            int hang=0;
            while ((len=br.readLine())!=null){
                String[] s = len.split(" ");
                sparseArr1[hang][0]=Integer.parseInt(s[0]);
                sparseArr1[hang][1]=Integer.parseInt(s[1]);
                sparseArr1[hang][2]=Integer.parseInt(s[2]);
                hang++;
            }
            return sparseArr1;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if (br != null) {
                    br.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
       return new int[0][0];
    }
}

3.4稀疏数组—>二维数组

//      把稀疏数组转换成二维数组
        int[][] arr1=new int[sparseArr[0][0]] [sparseArr[0][1]]    ;
        for (int i = 1; i < sparseArr.length; i++) {

                arr1[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];

        }

4.完整代码

import java.io.*;
import java.util.Arrays;
import java.util.stream.Stream;

/**
 * @author 86147
 * @ClassName : PACKAGE_NAME.sparseArr
 * @Description : 类描述
 * Created by user on 2021-06-24 22:53:04
 * Copyright  2020 user. All rights reserved.
 */
public class SparseArr {
    public static void main(String[] args) {
        int[][] arr= new int[11][11];
        arr[2][7]=1;
        arr[5][3]=2;
        arr[7][5]=3;
//        确定有效元素的个数
        int sum = getElementCount(arr);
//        根据有效元素个数创建稀疏数组
        int[][] sparseArr = getSparseArr(sum, arr);
//        用stream流打印二维数组,用stream流的of方法,把二维数组转换成一维数组
//         (一维数组a的元素是一维数组b,b数组元素是稀疏数组中一行的元素)
//        [11, 11, 3]
//        [2, 7, 1]
//        [5, 3, 2]
//        [7, 5, 3]
        Stream.of(sparseArr).forEach(t->System.out.println(Arrays.toString(t)));
//        将稀疏数组写入文件
       putSparseArrInFile(sparseArr,"a.txt");
//      将稀疏数组从文件中读取出来
        int[][] sparseArrOnFile = getSparseArrFromFile("a.txt");
        Stream.of(sparseArrOnFile).forEach(t->System.out.println(Arrays.toString(t)));


//      把稀疏数组转换成二维数组
        int[][] arr1=new int[sparseArr[0][0]] [sparseArr[0][1]]    ;
        for (int i = 1; i < sparseArr.length; i++) {

                arr1[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][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, 1, 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, 2, 0, 0, 0, 0, 0, 0, 0]
//        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
//        [0, 0, 0, 0, 0, 3, 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]
        Stream.of(arr1).forEach(t->System.out.println(Arrays.toString(t)));
    }
    public static int getElementCount(int[][]a){
        int sum=0;
        for (int[] ints : a) {
            for (int j = 0; j < a[0].length; j++) {
                if (ints[j] != 0) {
                    sum++;
                }
            }
        }
        return sum;
    }
    public static int[][] getSparseArr(int sum,int[][] arr){
        int[][] sparseArr=new int[sum+1][3];
//        将原数组的行数,列数和有效元素的个数赋值给稀疏数组的第一行
        sparseArr[0][0]=arr.length;
        sparseArr[0][1]=arr[0].length;
        sparseArr[0][2]=sum;
//        稀疏数组一行从左到右为有效元素的行号,列号,值,z用来记录该值为在稀疏数组的第几行
        int z=1;
//        将有效元素赋值给稀疏数组
        for (int i = 0; i < arr.length ; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                if (arr[i][j] != 0){

                    sparseArr[z][0] = i;
                    sparseArr[z][1] = j;
                    sparseArr[z][2] = arr[i][j];
                    z++;
                }
            }
        }
        return  sparseArr;
    }
    public static void putSparseArrInFile(int[][]a , String path){
        FileWriter fw=null;
        try {
            fw=new FileWriter("a.txt");
            for (int[] ints : a) {
                for (int anInt : ints) {
                    fw.write(anInt +" ");
                }
                fw.write("\n");
            }
            fw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                assert fw != null;
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
//
    public static int[][] getSparseArrFromFile(String path){
        BufferedReader br=null;
        int[][] sparseArr1 ;
        try {
            br=new BufferedReader(new FileReader(path));
            int sparseArrLength =0;
            while (br.readLine() !=null){
                sparseArrLength++;
            }
//            注意:这里的流已经将将整个文件读完了,所以要关闭该流,不然后面读出的为空
            br.close();
//            现在重新打开流
            br=new BufferedReader(new FileReader(path));
            sparseArr1=new int[sparseArrLength][3];
            String len="";
            int hang=0;
            while ((len=br.readLine())!=null){
                String[] s = len.split(" ");
                sparseArr1[hang][0]=Integer.parseInt(s[0]);
                sparseArr1[hang][1]=Integer.parseInt(s[1]);
                sparseArr1[hang][2]=Integer.parseInt(s[2]);
                hang++;
            }
            return sparseArr1;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if (br != null) {
                    br.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
       return new int[0][0];
    }
}
少季池鱼
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值