数据结构与算法入门——稀疏数组

当二维数组有大量0元素时，可进行数组压缩，形成稀疏数组

• 二维数组转稀疏数组的思路：

  • 1.遍历原始的二维数组，得到有效数据的个数value
  • 2.根据sum就可以创建稀疏数组sparseArray int[value+ 1][3]；
  • 3.将二维数组的有效数据数据存入到稀疏数组

• 稀疏数组转原始的二维数组的思路：

  • 1.先读取稀疏数组的第- -行，根据第一行的数据，创建原始的二维数组
  • 2.在读取稀疏数组后几行的数据，并赋给原始的二维数组即可.

//                          _ooOoo_                               //
//                         o8888888o                              //
//                         88" . "88                              //
//                         (| ^_^ |)                              //
//                         O\  =  /O                              //
//                      ____/`---'\____                           //
//                    .'  \\|     |//  `.                         //
//                   /  \\|||  :  |||//  \                        //
//                  /  _||||| -:- |||||-  \                       //
//                  |   | \\\  -  /// |   |                       //
//                  | \_|  ''\---/''  |   |                       //
//                  \  .-\__  `-`  ___/-. /                       //
//                ___`. .'  /--.--\  `. . ___                     //
//              ."" '<  `.___\_<|>_/___.'  >'"".                  //
//            | | :  `- \`.;`\ _ /`;.`/ - ` : | |                 //
//            \  \ `-.   \_ __\ /__ _/   .-` /  /                 //
//      ========`-.____`-.___\_____/___.-`____.-'========         //
//                           `=---='                              //
//      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        //
//                  佛祖保佑              永无BUG                  //


package LinearStructure.Array;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * @Author: 东方老赢
 * @Date: 2020/3/28 16:09
 *
 * 稀疏数组
 *
 * 二维数组转稀疏数组的思路：
 *  1.遍历原始的二维数组，得到有效数据的个数sum
 *  2.根据sum就可以创建稀疏数组sparseArr int[sum+ 1][3]
 *  3.将二维数组的有效数据数据存入到稀疏数组
 *
 * 稀疏数组转原始的二维数组的思路：
 *  1.先读取稀疏数组的第- -行，根据第一行的数据，创建原始的二维数组，比如上面的chessArr2 =int[11][11]
 *  2.在读取稀疏数组后几行的数据，并赋给原始的二维数组即可.
 */
public class SparseArray {
    public static void main(String[] args) {
        int[][] nums = new int[][]{{0,0,0,0,1,0,0},{0,2,0,0,0,3,0},{0,0,4,0,0,0,5},{0,6,0,0,0,7,0},{0,0,0,0,0,0,0},{0,0,0,8,0,0,0}};
        int[][] s = sparseArray(nums);
        for (int[] arr:s) {
            System.out.println(Arrays.toString(arr));
        }
        int[][] s2 = TwoArray(s);
        for (int[] arr:s2) {
            System.out.println(Arrays.toString(arr));
        }
    }
    /**
     *  二维数组转稀疏数组
     */
    public static int[][] sparseArray(int[][] nums){
        //1.遍历原始的二维数组，得到有效数据的个数sum
        int row = nums.length;
        int col = nums[1].length;
        int value = 0;
        Map<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[i].length; j++) {
                if (nums[i][j] != 0)
                    value ++;
            }
        }
        //2.根据sum就可以创建稀疏数组sparseArr int[sum+ 1][3]
        int[][] spArray= new int[value+1][3];
        //3.将二维数组的有效数据数据存入到稀疏数组
        spArray[0][0] = row;
        spArray[0][1] = col;
        spArray[0][2] = value;
        int index = 1;
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[i].length; j++) {
                if (nums[i][j] != 0) {
                    spArray[index][0] = i + 1;
                    spArray[index][1] = j + 1;
                    spArray[index][2] = nums[i][j];
                    index++;
                }
            }
        }

        return spArray;
    }

    /**
     * 稀疏数组转原始的二维数组
     * @param nums
     * @return
     */
    public static  int[][] TwoArray(int[][] nums){
         //1.先读取稀疏数组的第- -行，根据第一行的数据，创建原始的二维数组，比如上面的chessArr2 =int[11][11]
            int[][] twoArray = new int[nums[0][0]][nums[0][1]];
        //2.在读取稀疏数组后几行的数据，并赋给原始的二维数组即可.
        for (int i = 1; i < nums.length; i++) {
                twoArray[nums[i][0]-1][nums[i][1]-1] = nums[i][2];
        }
        return twoArray;
    }

}