数组（2）

二维数组

package JavaSE.D数组;
    /*
     1,2 arrays[0]
     2,3 arrays[1]
     3,4 arrays[2]
     4,5 arrays[3]
    */
public class 二维数组 {
    public static void main(String[] args) {
        int[][] arrays = {{1,2},{2,3},{3,4},{4,5}};
        System.out.println(arrays[0][1]);
        System.out.println("===============");
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j <arrays[i].length ; j++) {
                System.out.println(arrays[i][j]);
            }
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8FVysYtn-1612441075333)(E:\思维导图\二维数组.png)]

Arrays类

数组里有多种类可以调用，也可自己编写。

常用类有：给数组赋值：fill

​ 给数组排序：sort 升序

​ 比较数组 ：equals方法比较数组中元素是否相等

				查找元素数组：binarySearch 对排好序的数组进行二分查找

举例fill[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mlshE8r3-1612441075335)(C:\Users\Vechis\AppData\Roaming\Typora\typora-user-images\image-20210203183138471.png)]

        int[] a = {1, 4424, 663, 85, 31, 334};
  
        Arrays.fill(a,2,4,0);
        System.out.println(Arrays.toString(a));
结果：第2到第4个元素赋值为0

举例 sort排序

        int[] a = {1, 4424, 663, 85, 31, 334};
		Arrays.sort(a);     
		System.out.println(Arrays.toString(a)); //排序 sort
结果：[1, 31, 85, 334, 663, 4424]

举例toString 输出数组

        int[] a = {1, 4424, 663, 85, 31, 334};
        System.out.println(Arrays.toString(a));  //打印数组元素
        printArray(a);              //自写
        
    }

    public static void printArray(int[] a) {
        for (int i = 0; i < a.length; i++) {
            if (i == 0)
                System.out.print("[");
            if (i == a.length - 1) {
                System.out.print(a[i] + "]");
            } else {
                System.out.print(a[i] + ",");
            }
        }
    }

冒泡排序

时间复杂度：O（n2）

比较两个相邻的数大小，第一个数大于第二个数，交换两个位置

每次比较产生一个最大数和最小数 下一轮减少一次排序

依次循环，知道结束

public static void main(String[] args) {
        int[] array = {13,156,64,123,4586,3116,5123,1};
        int[] sort = sort(array);
        System.out.println(Arrays.toString(sort));
    }
    public static int[] sort(int[] array){
        int temp = 0;
        for (int i = 0; i < array.length-1; i++) {  //外层循环，判断要走几次
            boolean flag = false;   //通过flag标识符减少无意义比较
            for (int j = 0; j < array.length-1-i; j++) {    //内循环，比较两数并交换
                if(array[j+1]<array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if(flag==false)
                break;
        }
        return array;
    }

稀疏数组

package JavaSE.D数组;

public class I稀疏数组 {
    public static void main(String[] args) {
        // 1.创建一个二维数组 11*11  0:没有棋子 1：黑棋  2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数组
        System.out.println("输出原始数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            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];
                }
            }
        }
        //输出稀疏数组
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"+
                                array2[i][1]+"\t"+
                                array2[i][2]+"\t");
        }
        //还原成普通数组
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.给其中元素赋值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //打印
        System.out.println("输出还原的数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}