时间复杂度O(n²)之冒泡排序、选择排序法

前言

O(n²)：代表数据量增大n倍时，耗时增大n的平方倍，这是比线性更高的时间复杂度。对n个数排序，需要扫描n×n次
典型算法有：冒泡排序、选择排序法

冒泡排序

冒泡排序：时间复杂度O(n²),从第一个值开始，依次轮询，相邻的两个数依次比较，如果大于(正序排序)或者小于（倒序排序）则交换位置，即每一次轮询都会把最大的一个数冒泡到最后，轮询次数为length-1，每次轮询的长度都会减1

代码实现：

public class BubbleSort {

    public static void main(String[] args) {
        int[] array = new int[]{2, 5, 8, 34, 6, 7, 4, 3, 2, 45, 67, 3, 2, 455, 2};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }

    /**
     * 冒泡排序法，时间复杂度O(n²),从第一个值开始，相邻的两个数依次比较，如果前面的数大于后面的数，则替换
     * 即每一次轮询都会把最大的一个数冒泡到最后，轮询次数为length-1，每次轮询的长度都会减1
     */
    public static void bubbleSort(int arr[]) {
        // 外层循环控制需要冒泡比较的次数
        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]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }


}

选择排序

选择排序：时间复杂度O(n²),从第一个值开始，依次轮询，每次轮询把当前值替换为最大值，轮询次数为length-1，每次轮询的长度都会减1

代码实现：

public class SelectSort {

    public static void main(String[] args) {

        int[] oldList = new int[]{3,2,5,1,1,33,4,5,5,6,7,8,4,3,2,11,22,334,556,785,2,424,5,2,4};
        selectSort(oldList);
        System.out.println(Arrays.toString(oldList));

    }

    /**
     * 选择排序法，时间复杂度为O(n²)
     * 依次比较每个位置的最小值，找到最小值替换当前位置
     * @return
     */
    public static void selectSort(int[] arr) {
        // 外层循环控制轮询次数，从第一个位置开始
        for (int i = 0; i < arr.length; i++) {
            int minIndex = i;
            // 内层循环用于比较当前位置i的值的最小值索引
            for (int j = i+1; j < arr.length; j++) {
                // 如果有值比最小值还小，则替换索引
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            // 当前位置不是最小索引，则替换值
            if (minIndex != i) {
                int temp = arr[minIndex];
                arr[minIndex] = arr[i];
                arr[i] = temp;
            }
        }
    }

}

总结

冒泡排序和选择排序的时间复杂度都是O(n²)，但是其排序理念不同
冒泡排序：会依次比较相邻的值，如果不满足要求则替换彼此，里面即一直冒泡，把最大或者最小值依次冒泡到最顶端
选择排序：每次轮询都比较出最大或者最小值替换当前位置，不需要频繁替换，相对于冒泡排序不需要频繁替换，正确情况下效率要高于冒泡排序法

冒泡排序和选择排序比较像，要比较是那种算法可以根据是否需要保存一个索引值，更新索引值，选择排序是需要更新索引值的