算法数据结构：插入排序、冒泡排序、选择排序

Yerlang
484 阅读4分钟

1、插入排序

1.1、介绍

首先，我们将数组中的数据分为两个区间，已排序区间和未排序区间。初始已排序区间只有一个元素，就是数组的第一个元素。插入排序算法（Insertion Sort）的核心思想，是取未排序区间中的元素，在已排序区间中找到一个合适的插入位置，将其插入，并保证已排序区间一直有序。重复这个过程，直到未排序区间元素为空，算法结束。

1.2、分析

  1. 想让arr[0~0]上有序，这个范围只有一个数，当然是有序的。
  2. 想让arr[0~1]上有序，所以从arr[1]开始往前看，如果arr[1] < arr[0]，就交换。否则什么也不做。

…

  1. 想让arr[0~i]上有序，所以从arr[i]开始往前看，arr[i]这个数不停向左移动，一直移动到左边的数字不再比自己大，停止移动。
  2. 最后一步，想让arr[0~N-1]上有序， arr[N-1]这个数不停向左移动，一直移动到左边的数字不比自己大，停止移动。

估算时发现这个算法流程的复杂程度，会因为数据状况的不同而不同。

你发现了吗？

如果某个算法流程的复杂程度会根据数据状况的不同而不同，那么你必须要按照最差情况来估计。

很明显，在最差情况下，如果arr长度为N，插入排序的每一步常数操作的数量，还是如等差数列一般，所以

总的常数操作数量=a∗(N2)+b∗N+c总的常数操作数量 = a*(N^2) + b*N + c

其中，a、b、c 都是常数，所以插入排序排序的时间复杂度为O(N^2)。

1.3、实现

/**
 * @description: 插入排序
 * @author: erlang
 * @since: 2020-08-29 19:19
 */
public class InsertionSort {

    public static void insertionSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = 1; i < arr.length; i++) {
            // [0, i - 1] 有序的
            for (int j = i - 1; j >= 0 && arr[j + 1] < arr[j]; j--) {
                swap(arr, j, j + 1);
            }
        }
    }

    private static void swap(int[] arr, int j, int i) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

    public static void main(String[] args) {
        ArraySortUtils.testSort(InsertionSort::insertionSort, 100, 100);
    }
}

2、冒泡排序

2.1、介绍

冒泡排序（Bubble Sort）算法，只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求，如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复 n 次，就完成了 n 个数据的排序工作。

2.2、分析

在arr[0～N-1]范围上：

  1. arr[0]和arr[1]，谁大谁来到1位置；arr[1]和arr[2]，谁大谁来到2位置…arr[N-2]和arr[N-1]，谁大谁来到N-1位置
  2. 在arr[0～N-2]范围上，重复上面的过程，但最后一步是arr[N-3]和arr[N-2]，谁大谁来到N-2位置
  3. 在arr[0～N-3]范围上，重复上面的过程，但最后一步是arr[N-4]和arr[N-3]，谁大谁来到N-3位置

…

  1. 最后在arr[0～1]范围上，重复上面的过程，但最后一步是arr[0]和arr[1]，谁大谁来到1位置

很明显，如果arr长度为N，每一步常数操作的数量，依然如等差数列一般，所以 总的常数操作数量=a∗(N2)+b∗N+c总的常数操作数量 = a*(N^2) + b*N + c 其中，a、b、c 都是常数，所以冒泡排序的时间复杂度为 O(N2)O(N^2)。

2.3、实现

/**
 * @description: 冒泡排序
 * @author: erlang
 * @since: 2020-08-29 19:06
 */
public class BubbleSort {

    public static void bubbleSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }

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

    private static void swap(int[] arr, int i, int j) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

    public static void main(String[] args) {
        ArraySortUtils.testSort(BubbleSort::bubbleSort, 10, 100);
    }
}

3、选择排序

3.1、介绍

选择排序（Selection Sort）算法的思路类似插入排序，也分已排区间和未排区间。但是选择排序每次会从未排序区间中找到最小元素，将其放到已排序区间末尾。以此类推，直到所有元素均排序完毕。

选择排序是一种不稳定的原地排序算法。

3.2、分析

  1. arr[0～N-1]范围上，找到最小值所在的位置，然后把最小值交换到 0 位置。

  2. arr[1～N-1]范围上，找到最小值所在的位置，然后把最小值交换到 1 位置。

  3. arr[2～N-1]范围上，找到最小值所在的位置，然后把最小值交换到 2 位置。

    …

  4. arr[N-1～N-1]范围上，找到最小值位置，然后把最小值交换到 N-1 位置。

很明显，如果 arr 长度为 N，每一步常数操作的数量，如等差数列一般。所以 总的常数操作数量=a∗(N2)+b∗N+c总的常数操作数量 = a*(N^2) + b*N + c 其中，a、b、c 都是常数，所以选择排序的时间复杂度为 O(N2)O(N^2)。

3.3、实现

/**
 * @description: 选择排序
 * @author: erlang
 * @since: 2020-08-29 10:09
 */
public class SelectionSort {

    /**
     * @param arr 待排序数组
     */
    public static void selectionSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }

        for (int i = 0; i < arr.length - 1; i++) {
            // 记录最小值的索引
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                // 从 i + 1 到 length - 1 中找到比 arr[i] 小的最小值的索引
                minIndex = arr[j] < arr[minIndex] ? j : minIndex;
            }
            // 交换 i 和 minIndex 的值
            swap(arr, i, minIndex);
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
        int maxSize = 10;
        int maxValue = 10;
        ArraySortUtils.testSort(SelectionSort::selectionSort, maxSize, maxValue);
    }
}

4、测试工具类

import java.util.Arrays;
import java.util.function.Consumer;

/**
 * @description: 数组排序工具
 * @author: erlang
 * @since: 2020-08-29 10:49
 */
public class ArraySortUtils {

    /**
     * 随机生成待测试的数组
     *
     * @param maxSize  数组最大长度
     * @param maxValue 数组中最大的值
     * @return 返回生成的数组
     */
    public static int[] generateRandomArray(int maxSize, int maxValue) {
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
        }
        return arr;
    }

    /**
     * 输出数组的元素
     *
     * @param arr 数组
     */
    public static void printArray(int[] arr) {
        System.out.println("");
        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++START");
        for (int value : arr) {
            System.out.print(value + " ");
        }
        System.out.println("");
        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++END");
    }

    public static void comparator(int[] arr) {
        Arrays.sort(arr);
    }

    /**
     * 重新复制一个新数组
     *
     * @param arr 待复制的数组
     * @return 返回复制的新数组
     */
    public static int[] copyArray(int[] arr) {
        if (arr == null) {
            return null;
        }
        int[] res = new int[arr.length];
        System.arraycopy(arr, 0, res, 0, arr.length);
        return res;
    }

    /**
     * 比较两个数组的元素是否相等
     *
     * @param arr1 待比较的数组 1
     * @param arr2 待比较的数组 2
     * @return 返回校验结果 true/false
     */
    public static boolean isEqual(int[] arr1, int[] arr2) {
        if (arr1 == null && arr2 == null) {
            return true;
        }
        if (arr1 == null || arr2 == null) {
            return false;
        }
        if (arr1.length != arr2.length) {
            return false;
        }
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }
        return true;
    }

    /**
     * 测试排序方法的排序结果是否正确
     *
     * @param consumer 回调用户自定义的排序方法
     * @param maxSize  数组最大长度
     * @param maxValue 数组中最大的数，即 0 - maxValue
     */
    public static void testSort(Consumer<int[]> consumer, int maxSize, int maxValue) {
        int testTime = 5000;
        boolean succeed = true;
        for (int i = 0; i < testTime; i++) {
            // 生成新数组
            int[] arr1 = ArraySortUtils.generateRandomArray(maxSize, maxValue);
            // 复制新数组
            int[] arr2 = copyArray(arr1);
            // 回调用户自定义的排序方法，对 arri1 排序
            consumer.accept(arr1);
            // 使用系统自带的排序方法，对 arr2 排序
            comparator(arr2);
            // 比较两种处理结果是否一致
            if (!isEqual(arr1, arr2)) {
                succeed = false;
                printArray(arr1);
                printArray(arr2);
                break;
            }
        }
        // 输出测试结果
        System.out.println(succeed ? "Nice!" : "Error!");
    }
}

5、小结

本节主要介绍三种常用排序：插入排序、冒泡排序、选择排序

avatar
文章
阅读
粉丝