Java稀疏数组

Java稀疏数组

稀疏数组
1.创建一个二维数组 11*11 保存棋盘 0：没有棋子 1：黑棋 2：白棋
2.创建一个稀疏数组的数组
3.还原稀疏数组

package com.LittleWu.Array;
import com.sun.xml.internal.ws.addressing.WsaActionUtil;
public class ArrayDemo08 {
    public static void main(String[] args) {
        /*
        稀疏数组
            1.创建一个二维数组 11*11 保存棋盘 0：没有棋子 1：黑棋 2：白棋
            2.创建一个稀疏数组的数组
            3.还原稀疏数组
         */
        // 1.创建一个二维数组 11*11 保存棋盘 0：没有棋子 1：黑棋 2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        // 2.输出原始数组
        System.out.println("2.输出原始数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        System.out.println("=========================================================================");
        // 转换为稀疏数组保存
        // 获取有效值个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0){
                    sum++;
                }
            }
        }
        System.out.println("有效值个数为" + sum + "个。");
        // 2.创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        // 遍历二维数组，将非零值存放稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        // 输出稀疏数组
        System.out.println("输出稀疏数组:");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] + "\t" + array2[i][1] + "\t" + array2[i][2] + "\t");
        }
        // 还原稀疏数组
        System.out.println("还原稀疏数组:");
        System.out.println("=========================================================================");
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        // 其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        // 还原打印
        System.out.println("2.输出还原数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}

封装各功能后代码

package com.LittleWu.Array;
/***
 * ░░░░░░░░░░░░░░░░░░░░░░░░▄░░
 * ░░░░░░░░░▐█░░░░░░░░░░░▄▀▒▌░
 * ░░░░░░░░▐▀▒█░░░░░░░░▄▀▒▒▒▐
 * ░░░░░░░▐▄▀▒▒▀▀▀▀▄▄▄▀▒▒▒▒▒▐
 * ░░░░░▄▄▀▒░▒▒▒▒▒▒▒▒▒█▒▒▄█▒▐
 * ░░░▄▀▒▒▒░░░▒▒▒░░░▒▒▒▀██▀▒▌
 * ░░▐▒▒▒▄▄▒▒▒▒░░░▒▒▒▒▒▒▒▀▄▒▒
 * ░░▌░░▌█▀▒▒▒▒▒▄▀█▄▒▒▒▒▒▒▒█▒▐
 * ░▐░░░▒▒▒▒▒▒▒▒▌██▀▒▒░░░▒▒▒▀▄
 * ░▌░▒▄██▄▒▒▒▒▒▒▒▒▒░░░░░░▒▒▒▒
 * ▀▒▀▐▄█▄█▌▄░▀▒▒░░░░░░░░░░▒▒▒
 * 单身狗就这样默默地看着你，一句话也不说。
 */
public class Test02 {
    /*
       打印稀疏数组 原数组 还原数组
           0   0   0   0   0   0
           0   1   0   2   0   0
           0   0   1   2   0   0
           0   2   0   1   0   0
           0   2   0   2   1   0
           0   0   0   0   0   1
     */
    public static void main(String[] args) {
        int sum = 0;
        int[][] array1 = new int[6][6];
        array1[1][1] = 1;
        array1[1][3] = 2;
        array1[2][2] = 1;
        array1[2][3] = 2;
        array1[3][1] = 2;
        array1[3][3] = 1;
        array1[4][4] = 1;
        array1[5][5] = 1;
        array1[4][3] = 2;
        array1[4][1] = 2;
        PrintArrays(array1);
        sum = Value(array1);
        System.out.println("有效值个数为" + sum + "个");
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 6;
        array2[0][1] = 6;
        array2[0][2] = sum;
        ArrayHelp(array1,array2);
        System.out.println("=========================================================");
        System.out.println("上面的稀疏数组：");
        PrintArrays(array2);
        System.out.println("=========================================================");
        System.out.println("上面的稀疏数组还原：");
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        ArrayRelease(array2,array3);
        PrintArrays(array3);
    }
    // 打印二维数组元素方法
    public static void PrintArrays(int[][] arrays){ //数组可以封装成参数
        for (int i = 0; i < arrays.length; i++) {
            //System.out.print(arrays[i] + "\t");
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.print(arrays[i][j] + "\t");
            }
            System.out.println();
        }
    }
    // 寻找数组中的有效值 并返回有效值个数
    public static int Value(int[][] arrays){
        int value = 0;
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                if (arrays[i][j] != 0){
                    value++;
                }
            }
        }
        return value;
    }
    // 将数组中的有效值存入稀疏数组
    public static void ArrayHelp(int[][] array1,int[][] array2){
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
    }
    // 将稀疏数组释放
    public static void ArrayRelease(int[][] array1,int[][] array2){
        for (int i = 1; i < array1.length; i++) {
            array2[array1[i][0]][array1[i][1]] = array1[i][2];
        }
    }
}

运行结果为

0	0	0	0	0	0	
0	1	0	2	0	0	
0	0	1	2	0	0	
0	2	0	1	0	0	
0	2	0	2	1	0	
0	0	0	0	0	1	
有效值个数为10个
=========================================================
上面的稀疏数组：
6	6	10	
1	1	1	
1	3	2	
2	2	1	
2	3	2	
3	1	2	
3	3	1	
4	1	2	
4	3	2	
4	4	1	
5	5	1	
=========================================================
上面的稀疏数组还原：
0	0	0	0	0	0	
0	1	0	2	0	0	
0	0	1	2	0	0	
0	2	0	1	0	0	
0	2	0	2	1	0	
0	0	0	0	0	1	

Process finished with exit code 0