数据结构note1:稀疏数组/二维数组的转换

/**
 * instruction of project
 *
 * @author Aruiea.com
 * @ClassName LineADT
 * @Version 1.0
 * @Date 2020/7/13 20:58
 * 数据结构：线性结构，非线性结构
 * 线性结构：数据元素之间存在一对一之间的线性关系（数组，队列，链表，栈）
 *      存储方式：1.顺序表  2.l链表
 * 非线性结构：二维数组，多维数组，广义表，树结构，图结构
 */

//稀疏数组：二维数组中存储了许多无意义的数据，用sparseArray进行压缩
//        处理方法：记录有值得行列，值。
//         第0行存储 有效数据的row   col    有效数据个数val
//         第1行开始储存数据   row   col     val

//二维数组转稀疏数组的思路：
//    1.遍历原始数组，得到有效数据个数sum
//    2.根据sum创建稀疏数组sparseArr int[sum+1][3]
//    3.把二维数组的有效数据存储到稀疏数组中。

//稀疏数组转二维数组：
//    1.读取第一行，根据第一行，创建二维数组。
//    2.读取稀疏数组后几行数据，一一赋给二维数组
public class SparseArray  {

    public static void main(String[] args) {
        //创建一个原始二维数组11*11，0没有棋子，1黑子，2篮子。
        int[][] chessBoard = new int[11][11];
        SparseArray sparseArray = new SparseArray();
        chessBoard[1][2] = 1;
        chessBoard[2][3] = 2;
        chessBoard[4][3] = 2;
        chessBoard[4][4] = 1;

        //调用方法  转成稀疏数组
        int[][] doublArr = sparseArray.toSparseArray(chessBoard);

        //打印结果
        for (int[] ints : doublArr) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        //调用方法 转成二维数组
        int[][] doubleArray = sparseArray.toDoubleArray(doublArr);

        for (int[] ints : doubleArray) {
            for (int item : ints) {
                System.out.print(item+"\t");
            }
            System.out.println();
        }

    }

    //二维数组转稀疏数组
    public int[][] toSparseArray(int[][] array){
        //获得二维数组中有效的数组元素个数以及行数和列数，有效数据总数
        int rows = 0;
        int culs = 0;
        int sum = 0;

        //得到有效数据个数sum
        for (int[] ints : array) {
            for (int item : ints) {
                if (item != 0){
                    sum++;
                }
            }
        }

        //初始化稀疏数组第0行，分别是：所有数据的总行数       所有数据的总列数     所有有效数据的总个数
        int[][] sparseArray = new int[sum+1][3];
        sparseArray[0][0] = array.length;
        sparseArray[0][1] = array[0].length;
        sparseArray[0][2] = sum;

        //给剩余稀疏数组行赋值
        int counts = 1;//计数
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0){
                    sparseArray[counts][0] = i;//行
                    sparseArray[counts][1] = j;//列
                    sparseArray[counts][2] = array[i][j];//有效数据值
                    counts++;
                }
            }
        }
        return sparseArray;

    }

    //稀疏数组转二维数组
    public int[][] toDoubleArray(int[][] array){
        //创建初始二维数组容量
        int totalRows = array[0][0];
        int totalCuls = array[0][1];
        int[][] doubleArray = new int[totalRows][totalCuls];

        //给二维数组其他位置赋值
        for (int i = 1; i < array.length; i++) {
            int rowNum = array[i][0];
            int culNum = array[i][1];
            int value = array[i][2];

            doubleArray[rowNum][culNum] = value;
        }

        return doubleArray;
    }

}