Java--Arrays工具类、冒泡排序与稀疏数组

Java–Arrays工具类、冒泡排序与稀疏数组

package com.zy.base;

import java.util.Arrays;

/**
 *description: Java--数组工具类、冒泡排序与稀疏数组
 *@program: 基础语法
 *@author: zy
 *@create: 2023-02-17 15:10
 */
public class JavaArrays {

    public static void main(String[] args) {
        // 数组工具类Arrays的使用
        arraysOne();
        // 冒泡排序
        int[] c = {1,3,2,5,4,8,7,6};
        bubbleSort(c);
        System.out.println(toString(c));
        // 稀疏数组
        sparseArray();
    }

    public static void arraysOne(){
        int[] a = {1,3,2,5,4,8,7,6};
        int[] b = {1,3,2,5,4,8,7,6};
        int[] c = {1,3,2,5,4,8,7,6};

        System.out.println(a);// hashcode：[I@2503dbd3
        // 打印数组元素
        System.out.println(Arrays.toString(a));// [1, 3, 2, 5, 4, 8, 7, 6]

        Arrays.sort(a);// 数组排序：升序排序
        System.out.println(toString(a));// [1, 2, 3, 4, 5, 6, 7, 8]

        Arrays.fill(a,9);// 数组填充赋值：将所有数组元素都赋为给定的值
        System.out.println(toString(a));// [9, 9, 9, 9, 9, 9, 9, 9]

        // 数组比较：比较数组中元素值是否相等
        System.out.println(Arrays.equals(a,b));// false
        Arrays.fill(b,9);
        System.out.println(Arrays.equals(a,b));// true

        // 查找数组：对排序后的数组进行二分查找法操作
        Arrays.sort(c);
        System.out.println(Arrays.binarySearch(c,8));// 7
    }
    /**
     * @Description toString：Arrays.toString()源码
     * @author zy
     * [a]
     * java.lang.String
     * @date 2023-2-17 15:18
     */
    public static String toString(int[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }

    /**
     * @Description bubbleSort：冒泡排序：时间复杂度为O(n2)
     * 1.比较数组中两个相邻的元素，若第一个数比第二个数大就交换位置
     * 2.每次比较都会产生出一个最大或者最小的数字
     * 3.下一轮则可以少一次排序
     * 4.依次循环直到排序完毕
     * @author zy
     * [int[]]
     * void
     * @date 2023-2-17 15:50
     */
    public static void bubbleSort(int[] array){
        int max = 0;
        for(int i=0;i<array.length-1;i++){
            // 冒泡排序的优化
            boolean flag = false;
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j]>array[j+1]){
                    max = array[j];
                    array[j]=array[j+1];
                    array[j+1]=max;
                    flag = true;
                }
            }
            if(!flag){
                break;
            }
        }
    }

    /**
     * @Description 稀疏数组
     * 当一个数组中大部分值为0或者为同一值的数组时，可以使用稀疏数组来存放
     * 记录数组一共有几行几列，有多少个不同的值
     * 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
     * 总结：记录有效的坐标信息与有效值值
     * @author zy
     * []
     * void
     * @date 2023-2-17 16:18
     */
    public static void sparseArray(){
        // 创建一个二维数组 11*11  0：没有棋子，1：白棋，2：黑棋
        int[][] array2 = new int[11][11];
        array2[1][2] = 1;
        array2[2][3] = 2;

        System.out.println("原始的数组：");
        for (int[] array : array2) {
            for (int a : array) {
                System.out.print(a+"\t");
            }
            System.out.println();
        }

        /*
         转换为稀疏数组保存:
                行  列   值
           [0]  11  11  2
           [1]  1   2   1
           [2]  2   3   2

           1.获取有效值个数
           2.创建一个原始数组对应的稀疏数组：行为有效值个数+1（第一行为行数，列数，值的个数），列为固定的行列值3列
           3.遍历原始数组，将非0的值存放至稀疏数组中
         */
        int sum = 0;
        for (int[] array : array2) {
            for (int a : array) {
                if(a != 0){
                    sum++;
                }
            }
        }
        int[][] sparseArray = new int[sum+1][3];
        sparseArray[0][0] = array2.length;
        sparseArray[0][1] = array2[0].length;
        sparseArray[0][2] = sum;
        int count = 0;
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                if (array2[i][j]!=0){
                    count++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = array2[i][j];
                }
            }
        }
        System.out.println("稀疏数组：");
        for (int[] array : sparseArray) {
            for (int a : array) {
                System.out.print(a+"\t");
            }
            System.out.println();
        }

        /*
         还原稀疏数组：
         1.读取稀疏数组：创建还原数组，读取第一行稀疏数组赋值还原数组长度
         2.给其中的元素还原值：从第二行稀疏数组遍历，行列值依次赋回给还原数组
         3.打印查看是否还原
         */
        int[][] array3 = new int[sparseArray[0][0]][sparseArray[0][1]];
        for (int i = 1; i < sparseArray.length; i++) {
            array3[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        System.out.println("还原后的数组：");
        for (int[] array : array3) {
            for (int a : array) {
                System.out.print(a+"\t");
            }
            System.out.println();
        }
    }
}