数据结构和算法

1.稀疏数组

 

 

 

应用场景：

进行数据压缩：原本11*11的二位数组棋盘变成了

package com.pw.datastructure.study;

/**
 * @author pw
 * @version 1.0
 * @date 2022/7/27 17:46
 * 稀疏数组
 */
public class Day01 {

    public static void main(String[] args) {

        // 二维数组一共11行11列
        int[][] arr = new int[11][11];
        // 第2行，第3列的数据是1（下标从0开始）
        arr[1][2] = 1;
        // 第3行，第4列的数据是2
        arr[2][3] = 2;
        // 第一层for拿到行
        // 二维数组行数
        int rowSum = 0;
        int rowAndColumnSum = 0;
        for (int[] row : arr){
            rowSum ++;
            for (int column: row) {
                rowAndColumnSum++;
                System.out.print("\t"+column);
            }
            System.out.println();
        }
        // 二维数组列数
        int columnSum = rowAndColumnSum/rowSum;

        System.out.println("=======================二维数组转稀疏数组===========================");
        // 二维数组转稀疏数组

        // 1. 遍历二维数组,统计二维数组有效数据
        int sum = 0;
        for (int[] row : arr){
            for (int column: row) {
                if(column != 0){
                    sum++;
                }
            }
        }

        // 2.先创建一个稀疏数组（也是个二维数组）
        // 稀疏数组的行是二维数组有效数据的总数+1,列是固定为3
        int [][] sparseArr = new int [sum+1][3];
        System.out.println("二维数组行数是:"+ rowSum +"列数是:"+ columnSum);
        // 3.设置稀疏数组的第一行
        sparseArr[0][0] = rowSum;
        sparseArr[0][1] = columnSum;
        sparseArr[0][2] = sum;

        int sparseRow = 1;
        for (int i = 0; i < rowSum; i++) {
            for (int j = 0; j < columnSum; j++) {
                if(arr[i][j] != 0){
                    // 第一行后稀疏数组赋值
                    // 第几行
                    sparseArr[sparseRow][0] = i;
                    // 第几列
                    sparseArr[sparseRow][1] = j;
                    // 值
                    sparseArr[sparseRow][2] = arr[i][j];
                    sparseRow ++;
                }
            }
        }

        // 稀疏数组遍历（下标从0开始）
        for (int[] row : sparseArr){
            for (int data: row) {
                System.out.print("\t"+data);
            }
            System.out.println();
        }


        System.out.println("===========================稀疏数组转二维数组===========================");

        // 拿到稀疏数组的第一行
        int newArr [][]= new int[sparseArr[0][0]][sparseArr[0][1]];
        // 对应后面的赋值（第二行开始遍历，遍历的次数应该是稀疏数组的行数）
        for (int i = 1; i < sparseArr[0][2] + 1 ; i++) {
            // 重点！
            newArr[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }

        // 打印
        for (int[] row : newArr){
            for (int data: row) {
                System.out.print("\t"+data);
            }
            System.out.println();
        }



    }
}

结果：