稀疏数组（狂神）

说明：

• 之前学的时候没有学过稀疏数组，这次复习一边把它记录在博客，这是自己写的没按着老师视频来，供大家参考

• 想方法名和变量名真的给我想蒙了！！！

代码：

package com.luffy.array;


/**
 *
 * 稀疏数组
 *
 * */
public class Demo_08 {
    
    

    //取出存在值的总数
    private static int sum;
    //定义三个一维数组用来存储值的位置和值
    private static int[] line;
    private static int[] column;
    private static int[] value;
    //使存储指定数据的数组能够正常增长
    private static int number = 0;
    //初始棋盘数组
    private static int[][] numbers;
    //稀疏数组
    private static int[][] arrays;
    //复原棋盘数组
    private static int[][] recovery;


    public static void main(String[] args) {
    
    
        //定义一个初始的棋盘大数组
        numbers = new int[11][11];
        numbers[1][2] = 1;
        numbers[2][3] = 2;
        numbers[4][3] = 3;

        //打印初始棋盘数组
        printBoard(numbers);
        //得到稀疏数组中有效的总值
        validValues();
        //给稀疏数组的标题赋值
        arraysTitle();
        //将有效的值交给指定的数组来处理，并赋值给稀疏数组
        storyDataArray();
        //打印稀疏数组
        printSparseArray();
        //将稀疏数组复原成初始数组大棋盘
        recoveryArray();
        //打印复原后的稀疏数组
        printRecoveryArray();
    }


    /**
     * 打印初始棋盘数组
     * */
    public static void printBoard(int[][] numbers){
    
    
        System.out.println("原始大棋盘");
        for (int[] number : numbers) {
    
    
            for (int i : number) {
    
    
                System.out.print(i + "\t");
            }
            System.out.println();
        }
    }


    /**
     * 得到稀疏数组中有效的总值
     */
    public static void validValues(){
    
    
        for (int i = 0; i < numbers.length; i++) {
    
    
            for (int j = 0; j < numbers.length; j++) {
    
    
                if(numbers[i][j] != 0){
    
    
                    sum++;
                }
            }
        }
        //初始化指定数据数组
        line = new int[sum];
        column = new int[sum];
        value = new int[sum];
    }


    /**
     * 给稀疏数组的标题赋值
     * */
    public static void arraysTitle(){
    
    
        arrays = new int[sum + 1][3];
        arrays[0][0] = numbers.length;
        arrays[0][1] = numbers[10].length;
        arrays[0][2] = sum;
    }


    /**
     * 将有效的值交给指定的数组来处理，并赋值给稀疏数组
     * */
    public static void storyDataArray(){
    
    
        for (int i = 0; i < numbers.length; i++) {
    
    
            for (int j = 0; j < numbers.length; j++) {
    
    
                if(numbers[i][j] != 0){
    
    
                    //将查找到的值的位置和值交给指定的数组来处理
                    receive(i,j, numbers[i][j]);
                }
            }
        }
        //将处理好的数据存入稀疏数组
        for (int i = 1; i <= sum; i++) {
    
    
            arrays[i][0] = line[i-1];
            arrays[i][1] = column[i-1];
            arrays[i][2] = value[i-1];
        }
    }


    /**
     * 将存在的值的位置和值取出放入指定的数组
     */
    public static void receive(int a, int b, int c){
    
    
        line[number] = a;
        column[number] = b;
        value[number] = c;
        number++;
    }


    /**
     * 打印稀疏数组
     * */
    public static void printSparseArray(){
    
    
        System.out.println("转换成稀疏数组");
        for (int[] array : arrays) {
    
    
            for (int i : array) {
    
    
                System.out.print(i + "\t");
            }
            System.out.println();
        }
    }


    /**
     * 将稀疏数组复原成初始数组大棋盘
     * */
    public static void recoveryArray(){
    
    
        recovery = new int[numbers.length][numbers[10].length];
        //给复原数组添加数据
        for(int i = 0;i < line.length; i++){
    
    
            recovery[line[i]][column[i]] = value[i];
        }
    }

    /**
     * 打印复原后的稀疏数组
     */
    public static void printRecoveryArray(){
    
    
        System.out.println("打印复原后的稀疏数组");
        for (int[] ints : recovery) {
    
    
            for (int anInt : ints) {
    
    
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }


}

• 补充：本文章是按狂神老师学习的视频做的！
• 狂神老师学习网址：https://www.kuangstudy.com/