day08 数组补充(常见排序、方法和二维数组)

数组

1. 冒泡排序

冒泡排序：两个相邻的元素进行比较 如果条件成立 则交换位置

分析：

1.外层循环控制比较的轮数 轮数为长度-1 nums.length - 1

2.内层循环控制每一轮比较的次数 最多的一次是长度-1 后续每次递减1

冒泡排序：外层循环 n-1 内层循环 n-1-i

package com.atguigu.test1;
/**
 * 常见排序算法：冒泡 选择 归并 快速 希尔 猴子...
 *
 * 冒泡排序：两个相邻的元素进行比较 如果条件成立 则交换位置
 *
 * 分析：
 *      1.外层循环控制比较的轮数 轮数为长度-1 nums.length - 1
 *      2.内层循环控制每一轮比较的次数 最多的一次是长度-1 后续每次递减1
 *
*  冒泡排序：外层循环 n - 1   内层循环 n - 1 - i
 * */
public class Test1 {

    public static void main(String[] args) {
        int[] nums = {23, 546, 34, -45, 56, 10003, -56, -45654, 0};

        for (int i = 0;i < nums.length - 1;i++){
            for (int j = 0;j < nums.length - 1 - i;j++){
                if (nums[j] > nums[j + 1]){
                    int temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }

        System.out.println("--------------排序完成---------------");
        for (int i = 0;i < nums.length;i++){
            System.out.print(nums[i] + "\t");  // -45654	-56	-45	0	23	34	56	546	10003
        }
    }
}

2. 选择排序

选择排序：使用一个元素依次与其他的元素比较，遇到需要交换位置的元素，先不交换，等到一轮比较完成以后

交换一次位置

分析：

外层循环属于比较的数A 从第一个元素开始 直到倒数第二个元素 从0开始 小于长度 -1

内层循环属于比较的数B 从第二个元素开始 直到最后一个元素

从比较数A后边相邻的元素开始 i + 1 小于长度

package com.atguigu.test2;
/**
 * 选择排序：使用一个元素依次与其他的元素比较，遇到需要交换位置的元素，等到一轮比较完成以后 交换一次位置
 *
 * 分析：
 *      外层循环属于比较的数A 从第一个元素开始 直到倒数第二个元素 从0开始 小于长度-1
 *      内层循环属于比较的数B 从第二个元素开始 直到最后一个元素  从比较数A后边相邻的元素开始 i + 1 小于长度
 * */
public class Test1 {
    public static void main(String[] args) {
        int[] nums = {10, 23, 45, 8, 678};

        for (int i = 0;i < nums.length - 1;i++){
            int index = i;  // 定义变量用于记录当前 原本比较数A的下标
            for (int j = i + 1;j < nums.length;j++){
                if (nums[index] < nums[j]){
                    index = j;
                }
            }

            if (i != index){
                int temp = nums[i];
                nums[i] = nums[index];
                nums[index] = temp;
            }
        }

        System.out.println("----------比较完毕----------");

        for (int i = 0;i < nums.length;i++){
            System.out.print(nums[i] + "\t");  // 678	45	23	10	8
        }
    }
}

3. JDK提供快速排序

JDK排序：java.util.Arrays.sort(数组名); //JDK提供（升序）

有升序 也可以在升序的基础上 改为降序

package com.atguigu.test3;

import java.util.Arrays;

/**
 * JDK排序：java.util.Arrays.sort(数组名)：  JDK提供(升序)
 * 有升序 也可以在升序的基础上 改为降序
 * */
public class Test1 {
    public static void main(String[] args) {

        int[] nums = {12, 34, 65, 43, -123, 0};

        Arrays.sort(nums);

        for (int i = 0;i < nums.length;i++){
            System.out.print(nums[i] + "\t");  // -123	0	12	34	43	65
        }
        System.out.println();
    }
}

4. Arrays类常用方法

copyOf(原数组名,新长度) 复制数组

sort(数组名) 升序排序

binarySearch(数组名，查找元素) 查找执行元素在数组中的下标 要求必须先排序

fill(数组名，填充内容) 指定元素填充数组

toString(数组名) 将数组中的元素转换为字符串

package com.atguigu.test4;

import java.util.Arrays;

/**
 * copyOf(原数组，新长度) 复制数组
 * sort(数组名) 升序排序
 * binarySearch(数组名，查找元素)  查找执行元素在数组中的下标 要求必须先排序
 * fill(数组名，填充内容) 指定元素填充数组
 * toString(数组名) 将数组中的元素转换为字符串
 * */
public class Test1 {
    public static void main(String[] args) {

        int[] nums = {10, 34, 56, 32, -34, 0};

        Arrays.sort(nums);

        System.out.println("32在数组中的下标为：" + Arrays.binarySearch(nums, 34));  // 32在数组中的下标为：4

        // fill(数组名，填充内容) 指定元素填充数组
        int [] arr1 = new int[6];  // 默认值为0  6个0

        Arrays.fill(arr1, 999);  // 将999填充到数组中
        for (int i = 0;i < arr1.length;i++){
            System.out.print(arr1[i] + "\t");  // 999	999	999	999	999	999
        }
        System.out.println();

        // toString(数组名) 将数组中的元素转换为字符串
        System.out.println(Arrays.toString(arr1));  // [999, 999, 999, 999, 999, 999]


    }
}

5.二维数组(了解)

二维数组：数组中的元素还是数组

高维度：表示数组中有几个一维数组

低维度：表示一维数组中有几个元素

package com.atguigu.test5;

/**
 * 二维数组：数组中的元素还是数组
 * */
public class Test1 {
    public static void main(String[] args) {
        int[] nums1 = {1, 2, 3, 4, 5};

        int[][] nums2 = {{11, 22}, {234, 435, 54}, {123, 5, 34}};

        System.out.println(nums2[0]);  // [I@1540e19d
        System.out.println(nums2[0][0]);  // 11
        System.out.println(nums2[0][1]);  // 22

        System.out.println(nums2[1]);  // [I@677327b6
        System.out.println(nums2[1][0]);  // 234
        System.out.println(nums2[1][1]);  // 435
        System.out.println(nums2[1][2]);  // 54

        System.out.println(nums2[2]);   // [I@14ae5a5
        System.out.println(nums2[2][0]);  // 123
        System.out.println(nums2[2][1]);  // 5
        System.out.println(nums2[2][2]);  // 34

        System.out.println("----------------------------------");
        for (int i = 0;i < nums2.length;i++){
            for (int j = 0;j < nums2[i].length;j++){
                System.out.print(nums2[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

package com.atguigu.test5;

/**
 * 二维数组创建语法：四种方式
 *
 * 高维度：表示数组中有几个一维数组
 * 低维度：表示一维数组中有几个元素
 * */
public class Test2 {
    public static void main(String[] args) {
        // 先声明 再开辟空间 高维度长度必须写 低纬度可写可不写
        int[][] nums1;
        nums1 = new int[3][];

        nums1[0] = new int[5];  // 表示给二维数组中的第1个一维数组 开辟5个空间
        nums1[0][0] = 11;
        nums1[0][1] = 11;
        nums1[0][2] = 11;
        nums1[0][3] = 11;
        nums1[0][4] = 11;

        nums1[1] = new int[2];  // 表示给二维数组中的第2个一维数组 开辟2个空间
        nums1[1][0] = 22;
        nums1[1][1] = 22;

        nums1[2] = new int[4];  // 表示给二维数组中的第3个一维数组 开辟4个空间
        nums1[2][0] = 33;
        nums1[2][1] = 33;
        nums1[2][2] = 33;
        nums1[2][3] = 33;

        // 连声明带开辟空间
        int[][] nums2 = new int[4][5];
        for (int i = 0;i < nums2.length;i++){
            for (int j = 0;j < nums2[i].length;j++){
                System.out.print("*");
            }
            System.out.println();
        }

        // 连声明带赋值 繁琐
        int[][] nums3 = new int[][]{{11, 22, 33}, {44, 55}, {66, 77}};

        // 连声明带赋值 简单
        int [][] nums4 = {{11, 22}, {33, 44, 55}, {66, 77, 88}};
    }
}