9.冒泡排序和选择排序

冒泡排序

核心思想是循环length-1次，每次循序找出最大或者最小的一个数，每次比较相邻的两个数，如果大或者小就交换位置，每一次循环可以比较当次最大的一个数。
例如 3, 10, -1, 20,8

• 第一次循环
  1. 指针下移指向 3 3和10比较 不交换 3 10 -1 20 8
  2. 指针下移指向 10 10>-1 交换 3 -1 10 20 8
  3. 指针下移指向 10 10<20 不交换 3 -1 10 20 8
  4. 指针下移指向 20 20>8 交换 3 -1 10 8 20
  5. 退出第一次循环 找到最大的一个数 20 放在最后 最终结果 3 -1 10 8 20
• 第二循环一样的逻辑 找到最大的数 10 放在倒数第2的位置

public class BubbleSortDemo {

    public static void main(String[] args) {

        int arr[] = {3, 10, -1, 20,8};
        System.out.println(Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void bubbleSort(int[] arr) {
        int temp = 0;
        // 是否发生了交换
        boolean flag = false;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.println("第" + (i + 1) + "次交换: " + Arrays.toString(arr));
            if (!flag) {
                break;
            } else {
                flag = false;
            }
        }
    }
}

选择排序

核心思想是循环length-1次，每次循环找到剩余元素中最小或者最大的一个，然后交换位置

例3, 10, -1, 20,8

• 第一次循环 假定最小的是 arr[0] minIndex = 3 min=3

  一次循环剩余所有的数字 发现最小的是 -1 交换他们的位置 变成 -1 10 3 20 8

• 第二次循环 假定最小的数 10 arr[1] =10 minIndex = 1

  循环剩余所有数字 发现最小的是 3 则变成 -1 3 10 20 8

• 循环到length-1结束

public class SelectSortDemo {

    public static void main(String[] args) {
        int arr[] = {3, 9, -1, 10, 20};
        System.out.println(Arrays.toString(arr));
        selectSort(arr);
        System.out.println(Arrays.toString(arr));
    }


    public static void selectSort(int[] arr) {
        // 循环 length -1 次 如 5个数 只需要确定4个数的位置即可排序完成
        for (int i = 0; i < arr.length - 1; i++) {
            // 假定循环的第一个数为最小数
            int min = arr[i];
            int minIndex = i;
            // 循环遍历所有后面的数如果有比他小的 则修改minIndex的索引为最小数
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) {
                    minIndex = j;
                    min = arr[j];
                }
            }
            // 不是最小的需要交换
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
        }
    }
}