一篇文章让你了解选择排序与插入排序的实现过程与两者间的对比（Java 实现）

最新推荐文章于 2024-05-29 14:30:01 发布
最新推荐文章于 2024-05-29 14:30:01 发布
阅读量266 收藏
点赞数 3
分类专栏： 算法学习笔记 文章标签： 算法 排序算法 选择排序 插入排序 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41221623/article/details/89805581
版权

选择排序与插入排序的实现与对比（Java 实现）

选择排序

基本概念
首先，找到需要进行排序的数组中最小的那个元素，接着，将它和数组的第一个元素交换位置（如果第一个元素就是最小的元素那么将它和它自己进行交换）。接着，再在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置。以此类推，直到最后将整个数组排序。这就是选择排序的排序思想，它总是在不断地选择剩余元素之中的最小者。

其排序思想如下图所示(这里以排序 [8, 5, 2, 4] 为例)
选择排序流程

选择排序实现代码如下

/**
 * 选择排序的算法实现，将 array 按升序排列
 * 使用 Comparable 数组确保实现 Comparable 接口的类对象都可以用此方法进行选择排序
 *
 * @param array 进行选择排序的数组
 */
public static void sort(Comparable[] array) {

    // 取得数组长度
    int n = array.length;

    // 将 array[i] 和 array[i+1...N] 中最小的元素交换
    for (int i = 0; i < n; i++) {

        // 用于标记 array[i+1...N] 中最小元素的索引
        int minIndex = i;

        // 寻找当前 array[i+1...N] 中最小元素的索引
        for (int j = i + 1; j < n; j++) {

            // 判断当前 array[j] 是否比 array[minIndex] 还要小
            if (less(array[j], array[minIndex])) {

                // 还要小的话将最小元素的索引标记为 j
                minIndex = j;

            }

        }

        // 找到后将 array[i] 和 array[i+1...N] 中最小的元素交换
        swap(array, i, minIndex);

    }

}

/**
 * 判断元素 v 是否比元素 w 小
 *
 * @return 返回 true，则 v < w；反之 v >= w
 */
private static boolean less(Comparable v, Comparable w) {

    return v.compareTo(w) < 0;

}

/**
 * 交换数组 array 指定索引位置 i 和 j 的元素
 *
 * @param array 需要进行元素互换的数组
 * @param i     需要交换的元素的索引位置
 * @param j     需要交换的元素的索引位置
 */
private static void swap(Comparable[] array, int i, int j) {

    Comparable temp = array[i];
    array[i] = array[j];
    array[j] = temp;

}

从以上代码可知，选择排序的内部循环只是在比较当前元素与目前已知的最小元素谁大谁小，而且需要注意的是如果最小元素在数组中处于靠前的位置，那么它也不会提前停止，还是会继续比较剩余的元素。对于处于外部循环中的交换函数，它每次交换都能排定一个元素，比如一个数组第一次查找最小元素时最小元素在第一个位置，那么 i 和 minIndex 都会是同一个值，它不会说最小元素还是自己就不会进行交换，还是会执行交换函数将它和它自己进行互换。所以对于交换函数来说，交换的总次数总是 n。所以，算法的时间效率就取决于内部循环中比较的次数。

此处引入一个命题：对于长度为 N 的数组，选择排序需要大约 N2/2 次比较和 N 次交换。

选择排序的特点

  1. 运行时间和输入无关。
    对于选择排序来说，排序的数组不管是已经有序的还是元素全都是一样的又或者是元素全部随机分布的，它所耗费的时间都是相差不大的。

    此处引入一个我用于测试排序算法的测试类

    import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Random;

/**
 * 测试各排序算法的工具类
 *
 * @author 踏雪彡寻梅
 * @version 1.0
 * @date 2019-05-14 23:57
 */
public class SortCompare {

	/**
	 * 该测试类不产生任何实例
	 */
    private SortCompare(){}

    /**
     * 判断元素 v 是否比元素 w 小
     *
     * @return 返回 true，则 v < w；反之 v >= w
     */
    private static boolean less(Comparable v, Comparable w) {

        return v.compareTo(w) < 0;

    }

    /**
     * 检测 array 是否排序成功
     * @param array 进行检测的数组
     * @return 返回 true 表示排序成功，返回 false 表示排序失败
     */
    private static boolean isSorted(Comparable[] array){

        int n = array.length;

        for (int i = 1; i < n; i++){

            // 如果某个元素比它前面的一个元素还要小，说明排序失败
            if(less(array[i], array[i - 1])){

                return false;

            }

        }

        return true;

    }

    /**
     * 返回运行 sortName 排序算法所需要的时间，单位：秒
     * @param sortName 进行测试的排序算法的类名称
     * @param array 进行排序的数组
     * @return 返回排序算法运行的时间
     */
    public static double time(String sortName, Comparable[] array){

        // 排序总用时,单位：秒
        double totalTime = 0.0;

        // 通过 Java 的反射机制，通过排序算法的类名，运行排序函数
        try {

            // 通过 sortName 获得排序函数的 Class 对象
            Class sortClass = Class.forName(sortName);
            // 通过排序函数的 Class 对象获得排序方法
            Method sortMethod = sortClass.getMethod("sort", new Class[]{ Comparable[].class });
            // 使用 array 数组生成排序函数的排序参数，各排序函数的参数只有一个，即 array 数组
            Object[] params = new Object[]{array};


            // 算法开始运行时的时间
            long startTime = System.currentTimeMillis();
            // 调用排序函数
            sortMethod.invoke(null, params);
            // 算法结束时的时间
            long endTime = System.currentTimeMillis();

            // 检测排序是否成功
            assert isSorted(array);

            // 计算排序用时，单位：秒
            totalTime = (endTime - startTime) / 1000.0;

        } catch (Exception e){

            System.err.println("计算排序算法运行时间失败！");
            e.printStackTrace();

        }

        return totalTime;

    }

    /**
     * 使用排序算法 sortName 对 T 个长度为 N 的随机数组进行排序测试，计算 T 次测试的总时间
     * @param sortName 进行测试的排序算法的类名称
     * @param N 测试数组的元素个数
     * @param T 测试次数
     * @return 返回测试的总时间，单位：秒
     */
    public static double timeRandomInput(String sortName, int N, int T){

        // 随机数种子
        long seed = System.currentTimeMillis();
        Random random = new Random(seed);

        // 总时间
        double totalTime = 0.0;

        // 进行测试的随机数组，这里使用 Double 类型的数组
        // 各元素的范围为 [0.0, 1.0)
        // 这样几乎不可能产生相等的主键值
        Double[] array = new Double[N];

        for (int t = 0; t < T; t++){

            // 进行一次测试（生成一个随机数组并排序）
            for (int i = 0; i < N; i++) {
				
				// 范围: [0.0, 1.0)
                array[i] = random.nextDouble();

            }

            // 对生成的随机数组进行时间计算，并同时记录到总时间中
            totalTime += time(sortName, array);

        }

        return totalTime;

    }

    /**
     * 生成有 n 个元素的随机数组,每个元素的随机范围为 [0.0, 1.0)
     * 这里的测试用例只生成 Double 型的测试用例
     * 各元素的范围为 [0.0, 1.0)
     * 这样几乎不可能产生相等的主键值
     * @param n 数组的元素个数
     * @return 返回一个测试用例数组
     */
    public static Double[] generateRandomArray(int n) {

        // 随机数种子
        long seed = System.currentTimeMillis();
        Random random = new Random(seed);

        // 测试用例数组
        Double[] array = new Double[n];

        for (int i = 0; i < n; i++) {

            // 范围: [0.0, 1.0)
            array[i] = random.nextDouble();

        }

        // 返回测试用例数组
        return array;

    }

    /**
     * 生成有 n 个元素的 Integer 型随机数组,每个元素的随机范围为 [rangeL, rangeR]
     * @param n 数组的元素个数
     * @param rangeL 元素的最小值
     * @param rangeR 元素的最大值
     * @return 返回一个测试用例数组
     */
    public static Integer[] generateRandomArray(int n, int rangeL, int rangeR) {

        // 检查元素的左范围是否小于等于右范围
        assert rangeL <= rangeR;

        // 用于存储随机生成的测试用例
        Integer[] array = new Integer[n];

        for (int i = 0; i < n; i++) {

            // 范围：[rangeL, rangeR]
            array[i] = (int) (Math.random() * (rangeR - rangeL + 1) + rangeL);

        }

        // 返回测试用例数组
        return array;

    }

    /**
     * 生成一个近乎有序的 Integer 型测试用例数组
     * 首先生成一个含有 [0...n-1] 的完全有序数组, 之后随机交换 swapTimes 对数据
     * swapTimes 定义了数组的无序程度:
     * swapTimes == 0 时, 数组完全有序
     * swapTimes 越大, 数组越趋向于无序
     * @param n 希望生成数组的元素个数
     * @param swapTimes 交换的元素对数
     * @return 返回一个近乎有序的测试用例数组
     */
    public static Integer[] generateNearlyOrderedArray(int n, int swapTimes){

        Integer[] array = new Integer[n];

        for( int i = 0 ; i < n ; i ++ ) {

            array[i] = i;

        }

        for( int i = 0 ; i < swapTimes ; i ++ ){

            // 随机生成一对交换索引
            int a = (int)(Math.random() * n);
            int b = (int)(Math.random() * n);

            // 交换
            int temp = array[a];
            array[a] = array[b];
            array[b] = temp;

        }

        return array;

    }

    /**
     * 生成一个有 n 个元素的 Integer 型逆序（递减）测试用例数组
     * @param n 数组元素个数
     * @return 返回一个逆序的测试用例数组
     */
    public static Integer[] generateInvertedArray(int n){

        Integer[] array = new Integer[n];
        int index = 0;

        for (int i = n - 1; i >= 0; i--) {

            array[index++] = i;

        }

        return array;

    }

    /**
     * 生成一个数量级为 n 的具有大量相同元素的 Integer 型测试用例数组
     * n 必须为 100 的倍数
     * @param n 数组元素个数
     * @return 返回一个具有大量相同元素的测试用例数组
     */
    public static Integer[] generateManySameElementsArray(int n){

        assert n % 100 == 0;

        Integer[] array = new Integer[n];
        int index = 0;

        for (int i = 0; i < n / 100; i++) {

            // range: [0, 5]
            int element = (int) (Math.random() * (5 + 1) + 0);
            
            for (int j = 0; j < 100; j++){

                array[index++] = element;

            }

        }

        return array;

    }

    /**
     * 打印 array 数组的所有内容
     * @param array 要进行打印的数组
     */
    public static void printArray(Object[] array) {

        System.out.print("当前数组中元素: [");

        for (int i = 0; i < array.length; i++){

            if(i != array.length - 1) {

                System.out.print(array[i]);
                System.out.print(", ");

            } else {

                System.out.println(array[i] + "]");

            }

        }

    }

    /**
     * 使用排序算法 sortName 对数组 array 进行 T 次排序测试，取平均时间，单位：秒
     * @param sortName 进行测试的排序算法类名称
     * @param array 进行测试的数组
     * @param T 测试次数
     */
    public static void test(String sortName, Comparable[] array, int T){

        // 总时间
        double totalTime = 0.0;

        // 临时数组，用于重复测试 array 所用
        Comparable[] tempArray = Arrays.copyOf(array, array.length);

        for (int t = 0; t < T; t++){

            totalTime += time(sortName, array);
            // 避免重复排序已经有序的 array
            array = Arrays.copyOf(tempArray, tempArray.length);

        }

        // 平均时间
        final double avg = totalTime / T;

        // 输出结果
        System.out.printf("排序算法：%s, 排序数量级：%d, 测试 %d 次平均耗时：%.7f s\n", sortName, array.length, T, avg);

    }

    /**
     * 显示两个排序算法 sortName1 和 sortName2 的对比结果
     * @param sortName1 进行对比的排序算法的名称
     * @param sortName2 进行对比的排序算法的名称
     * @param N 两种排序算法测试的数量级
     * @param time1 sortName1 排序所需的时间
     * @param time2 sortName2 排序所需的时间
     */
    public static void showCompareResult(String sortName1, String sortName2, int N, double time1, double time2){

        // 两者之比
        final double ratio;

        //
        if(time1 > time2){

            ratio = time1 / time2;
            System.out.println("For " + N + " elements");
            System.out.println(sortName1 + " ---> time1: " + time1 + " s");
            System.out.println(sortName2 + " ---> time2: " + time2 + " s");
            System.out.printf("\t%s is %.7f times faster than %s.\n", sortName2, ratio, sortName1);

        } else if(time1 <= time2) {

            ratio = time2 / time1;
            System.out.println("For " + N + " elements");
            System.out.println(sortName1 + " ---> time1: " + time1 + " s");
            System.out.println(sortName2 + " ---> time2: " + time2 + " s");
            System.out.printf("\t%s is %.7f times faster than %s.\n", sortName1, ratio, sortName2);

        }




    }

    /**
     * 测试工具类
     */
    public static void main(String[] args) {
        
        final int N = 2_0000;
        final int T = 20;

        double time1 = timeRandomInput("selectionsort.SelectionSort", N, T);
        double time2 = timeRandomInput("insertionsort.InsertionSort", N, T);

        showCompareResult("SelectionSort", "InsertionSort", N, time1, time2);

        System.out.println("\n=====================\n");

        Double[] array1 = generateRandomArray(N);
        Double[] array2 = Arrays.copyOf(array1, array1.length);
        test("selectionsort.SelectionSort", array1, T);
        test("insertionsort.InsertionSort", array2, T);

    }
    
}

    测试代码

    /**
 * 测试用例
 */
public static void main(String[] args) {

   	final int N = 2_0000;
    final int T = 20;

    System.out.println("测试对各元素随机分布的数组进行排序: ");
    Double[] array1 = SortCompare.generateRandomArray(N);
    // selectionsort.SelectionSort: 我的选择排序写在了 SelectionSort 类中，这个类我放在在包 selectionsort 中，所以这里这样传参
    SortCompare.test("selectionsort.SelectionSort", array1, T);

    System.out.println("\n=============================\n");

    System.out.println("测试对各元素都相等的数组进行排序: ");
    Integer[] array2 = SortCompare.generateRandomArray(N, 0, 0);
    SortCompare.test("selectionsort.SelectionSort", array2, T);

    System.out.println("\n=============================\n");

    System.out.println("测试对近乎有序的数组进行排序：");
    int swapTimes = 100;
    Integer[] array3 = SortCompare.generateNearlyOrderedArray(N, swapTimes);
    SortCompare.test("selectionsort.SelectionSort", array3, T);

    System.out.println("\n=============================\n");

    System.out.println("测试对完全有序的数组进行排序: ");
    swapTimes = 0;
    Integer[] array4 = SortCompare.generateNearlyOrderedArray(N, swapTimes);
    SortCompare.test("selectionsort.SelectionSort", array4, T);

    System.out.println("\n=============================\n");

    System.out.println("测试对有大量相同元素的数组进行排序：");
    Integer[] array5 = SortCompare.generateManySameElementsArray(N);
    SortCompare.test("selectionsort.SelectionSort", array5, T);

    System.out.println("\n=============================\n");

    System.out.println("测试对元素呈降序排列的数组进行排序：");
    Integer[] array6 = SortCompare.generateInvertedArray(N);
    SortCompare.test("selectionsort.SelectionSort", array6, T);

}

    测试结果
    选择排序测试
    从结果可以看出，排序的数组不管是已经有序的还是元素全都是一样的又或者是元素全部随机分布的再或者其他情况的，它进行排序所耗费的时间都是相差不大的。

  2. 数据移动是最少的。
    在选择排序中，交换次数和数组的大小是有关系的，对于长度为 N 的数组，选择排序需要进行 N 次交换，所以它的交换次数和数组的大小是线性关系。对于其他算法来说，大部分的增长数量级都是线性对数或是平方级别。

插入排序

基本概念
在我们平时打扑克牌时，整理时总是一张一张的来，将每一张牌插入到其他已经有序的牌中的适当位置。插入排序也是大致的道理，为了给需要插入的元素腾出空间，需要将其余所有元素在插入之前都向右移动一位。

算法思想如下图所示（这里以排序 [8, 5, 2, 4] 为例）
插入排序流程

和选择排序的异同

  1. 和选择排序一样，当前索引左边的所有元素都是有序的，但它们的最终位置还不确定，为了给后续元素中更小的元素腾出空间，它们可能会被移动。当索引到达数组的右端时，数组排序就完成了。
  2. 和选择排序不同的是，插入排序所需的时间取决于输入中元素的初始顺序。例如，对一个很大且其中元素已经有序（或者近乎有序）的数组进行排序将会比随机顺序的数组或是逆序数组进行排序要快得多。

此处引入一个命题：对于随机排列的长度为 N 且各元素不重复的数组，平均情况下插入排序需要大约 N2/4 次比较及大约 N2/4 次交换。最坏情况（逆序数组）需要大约 N2/2 次比较和大约 N2/2 次交换，最好情况（数组已经有序）需要 N - 1 次比较和 0 次交换。

插入排序的特性

  • 插入排序对于实际应用中常见的某些类型的非随机数组很有效。例如当用插入排序对一个有序数组进行排序时，插入排序能够立即发现每个元素都已经在合适的位置之上，它的运行时间也是线性的（对于这种数组，选择排序的运行时间是平方级别的）。
  • 同理，插入排序对近乎有序的数组进行排序时也是很有效的。当数组中不在正确位置（数组有序时元素所在的位置）上的元素越少的时候，插入排序排序的速度就会越快。

插入排序实现代码如下

/**
 * 插入排序未优化写法
 * 将 array 按升序排列
 *
 * @param array 进行插入排序的数组
 */
public static void sort(Comparable[] array) {

    // 取得数组长度
    int n = array.length;

    // 将 array[i] 插入到 array[i-1], array[i-2], array[i-3]...之中
    for (int i = 1; i < n; i++) {

        for (int j = i; j > 0 && less(array[j], array[j - 1]); j--) {

            swap(array, j, j - 1);

        }

    }

}

/**
 * 判断元素 v 是否比元素 w 小
 *
 * @return 返回 true，则 v < w；反之 v >= w
 */
private static boolean less(Comparable v, Comparable w) {

    return v.compareTo(w) < 0;

}

/**
 * 交换数组 array 指定索引位置 i 和 j 的元素
 *
 * @param array 需要进行元素互换的数组
 * @param i     需要交换的元素的索引位置
 * @param j     需要交换的元素的索引位置
 */
private static void swap(Comparable[] array, int i, int j) {

    Comparable temp = array[i];
    array[i] = array[j];
    array[j] = temp;

}

从以上代码可以看出，对于 1 到 N - 1 之间的每一个 i，将 array[i] 与 array[0] 到 array[i - 1] 中比它小的所有元素依次有序地交换。在索引 i 由左向右变化的过程中，它左侧的元素总是有序的，所以当 i 到达数组的右端时排序就完成了。

也可以看出对于每次与前面的元素进行交换时都需要进行三次赋值操作，这显然是会耗费一些时间的，所以以上算法可改进如下：

/**
 * 插入排序优化写法
 * 此写法访问数组的次数比使用交换函数的写法少了一半左右，可以提升一些效率
 * 将 array 按升序排列
 *
 * @param array 进行插入排序的数组
 */
public static void sort(Comparable[] array) {

    // 取得数组长度
    int n = array.length;

    // 将 array[i] 插入到 array[i-1], array[i-2], array[i-3]...之中
    for (int i = 1; i < n; i++) {

        // 先将 array[i] 复制一份
        Comparable e = array[i];

        int j = i;
        for (; j > 0 && less(e, array[j - 1]); j--) {

            // 将较大的元素往右移
            array[j] = array[j - 1];

        }

        // 最后将 e 赋值回来，确保插入排序成功
        array[j] = e;

    }

}

以上代码的思路如下图所示（这里以排序 [8, 5, 2, 4] 为例）：
优化后的插入排序流程

现在对两种写法分别进行测试一遍，以观察这两种写法的效率。

测试代码

/**
 * 测试插入排序
 */
public static void main(String[] args) {

    final int N = 2_0000;
    final int T = 20;

    System.out.println("测试对各元素随机分布的数组进行排序, 各元素范围：[0.0, 1.0)。");
    Double[] array1 = SortCompare.generateRandomArray(N);
    // insertionsort.InsertionSort: 我的插入排序写在了 InsertionSort 类中，这个类我放在在包 insertionsort 中，所以这里这样传参
    SortCompare.test("insertionsort.InsertionSort", array1, T);

    System.out.println("\n=============================\n");

    System.out.println("测试对各元素都相等的数组进行排序, 各元素值：0。");
    Integer[] array2 = SortCompare.generateRandomArray(N, 0, 0);
    SortCompare.test("insertionsort.InsertionSort", array2, T);

    System.out.println("\n=============================\n");

    System.out.println("测试对完全有序的数组进行排序: ");
    int swapTimes = 0;
    Integer[] array3 = SortCompare.generateNearlyOrderedArray(N, swapTimes);
    SortCompare.test("insertionsort.InsertionSort", array3, T);

    System.out.println("\n=============================\n");

    System.out.println("测试对近乎有序的数组进行排序: ");
    swapTimes = 100;
    Integer[] array4 = SortCompare.generateNearlyOrderedArray(N, swapTimes);
    SortCompare.test("insertionsort.InsertionSort", array4, T);

    System.out.println("\n=============================\n");

    System.out.println("测试对有大量相同元素的数组进行排序：");
    Integer[] array5 = SortCompare.generateManySameElementsArray(N);
    SortCompare.test("insertionsort.InsertionSort", array5, T);

    System.out.println("\n=============================\n");

    System.out.println("测试对元素呈降序排列的数组进行排序：");
    Integer[] array6 = SortCompare.generateInvertedArray(N);
    SortCompare.test("insertionsort.InsertionSort", array6, T);

}

使用未优化写法时的测试结果
插入排序未优化写法测试结果
使用优化写法时的测试结果
插入排序优化写法测试结果

可以看出，使用优化的写法时在效率上比未优化的写法快速了一些。这是因为使用优化的写法时访问数组的次数会比使用未优化的写法少了一半左右，可以提升一些效率。

总的来说，插入排序对于近乎有序的数组十分高效，也很适合小规模数组。

选择排序和插入排序的效率对比

最后，在通过一组测试用例来进行选择排序和插入排序的效率对比，来观察在各情况下两种算法的效率。

测试代码

public static void main(String[] args) {

	final int N = 2_0000;
    final int T = 20;

    System.out.println("测试对各元素随机分布的数组进行排序, 各元素范围：[0.0, 1.0)。");

    Double[] array1 = SortCompare.generateRandomArray(N);
    Double[] array2 = Arrays.copyOf(array1, array1.length);

    SortCompare.test("selectionsort.SelectionSort", array1, T);
    SortCompare.test("insertionsort.InsertionSort", array2, T);

    System.out.println("\n=============================\n");

    System.out.println("测试对有大量相同元素的数组进行排序：");

    Integer[] array3 = SortCompare.generateManySameElementsArray(N);
    Integer[] array4 = Arrays.copyOf(array3, array3.length);

    SortCompare.test("selectionsort.SelectionSort", array3, T);
    SortCompare.test("insertionsort.InsertionSort", array4, T);

    System.out.println("\n=============================\n");

    int swapTimes = 100;
    System.out.println("测试对近乎有序的数组进行排序: ");

    array3 = SortCompare.generateNearlyOrderedArray(N, swapTimes);
    array4 = Arrays.copyOf(array3, array3.length);

    SortCompare.test("selectionsort.SelectionSort", array3, T);
    SortCompare.test("insertionsort.InsertionSort", array4, T);

    System.out.println("\n=============================\n");

    System.out.println("测试对各元素都相等的数组进行排序, 各元素值：0。");

    array3 = SortCompare.generateRandomArray(N, 0, 0);
    array4 = Arrays.copyOf(array3, array3.length);

    SortCompare.test("selectionsort.SelectionSort", array3, T);
    SortCompare.test("insertionsort.InsertionSort", array4, T);

    System.out.println("\n=============================\n");

    System.out.println("测试对完全有序的数组进行排序: ");

    swapTimes = 0;
    array3 = SortCompare.generateNearlyOrderedArray(N, swapTimes);
    array4 = Arrays.copyOf(array3, array3.length);

    SortCompare.test("selectionsort.SelectionSort", array3, T);
    SortCompare.test("insertionsort.InsertionSort", array4, T);

    System.out.println("\n=============================\n");

    System.out.println("测试逆序排列的数组：");

    array3 = SortCompare.generateInvertedArray(N);
    array4 = Arrays.copyOf(array3, array3.length);

    SortCompare.test("selectionsort.SelectionSort", array3, T);
    SortCompare.test("insertionsort.InsertionSort", array4, T);

    System.out.println("\n=============================\n");

    System.out.println("测试 " + T + " 种 " + N + " 数量级的随机数组( random range: [0.0, 1.0) )两种排序算法的效率之比：");

    double time1 = SortCompare.timeRandomInput("selectionsort.SelectionSort", N, T);
    double time2 = SortCompare.timeRandomInput("insertionsort.InsertionSort", N, T);

    SortCompare.showCompareResult("SelectionSort", "InsertionSort", N, time1, time2);

}

测试结果
选择排序和插入排序的对比

观察前 6 个测试，可以看出在各元素随机分布的数组中，选择排序和插入排序的效率都差不多。而在逆序数组中，选择排序的速度要快过插入排序。对于其他四种情况，插入排序都要比选择排序更快。对于最后一个测试，是用这两种排序算法对 20 个不同的随机数组进行排序，统计出它们各自的总时间，然后进行对比。可以看出在此测试中，选择排序要稍稍快过插入排序一些，它们的时间之比是一个较小的常数，有时候可能会是插入排序快过选择排序一些。

小结

  • 对于随机排序的无重复元素的数组，插入排序和选择排序的运行时间是平方级别的，两者之比应该是一个较小的常数。
  • 对于逆序数组，选择排序的速度要快于插入排序。
  • 对于具有大量相同元素的数组、近乎有序的数组、各元素都相等的数组和完全有序的数组，插入排序的速度都快于选择排序。
  • 插入排序对于近乎有序的数组十分高效，也很适合小规模数组。

如有写的不足的，请见谅，请大家多多指教。
我的个人博客网站: www.xilikeli.cn 欢迎大家来访(#.#)

踏雪彡寻梅
关注
专栏目录
（面经总结）一篇文章带你整理面试过程中关于 Java 中的集合 List，Queue，Set的相关知识点
南淮北安的博客
04-30 343
文章目录一、 List：可重复1. ArrayList：基于数组实现，增删慢，查询快，线程不安全2. Vector：基于数组实现，增删慢，查询快，线程安全3. LinkedList：基于双向链表实现，增删快，查询慢，线程不安全4. 三者的区别联系二、Queue三、Set：不可重复1. HashSet:HashTable实现，无序2. TreeSet：二叉树实现3. LinkHashSet:HashTable实现数据存储，双向链表记录顺序四、分析比较五、面试题 数组：可以存储对象，也可以存储基本数据类型，但
Java-选择排序和插入排序
qq_37141156的博客
03-15 131
选择排序： 给定一个数组arr，长度为N，首先找到该数组的最小值，与数组的第一个数arr[0]交换位置，然后再在剩余的N-1个数中找最小的数，与数组的第二个数arr[1]交换位置，以此类推直到数组中N-1个数排好位置，排序结束。 由于每一趟都要遍历数组的剩余部分，共有N-1趟，所以算法的时间复杂度为O(n^2)。排序过程没有临时申请内存空间，空间复杂度为O(1)。如果数组中出现相等的数字，选择排序过程中可能会打乱其之间的前后位置，所以选择排序是不稳定的。 public static void main(St
基本排序算法——插入排序和选择排序
xiaoxionghanhan的博客
07-14 205
插入排序逻辑： 1、从第二位开始，向前比较，进入插入逻辑 2、如果遇到比自己大的，大的值就后移 3、如果遇到比自己小的，就在其后方插入 4、如果一直没有插入，就放在首位 主要代码如下： public class Demo6 { public static void main(String[] args) { //从第二位开始，向前比较，进行插入逻辑 int[] a={1,3,2,5,8,4}; for (int i = 0; i < a.length; i++) { int tmp=a[i]; boo
排序专题(3)——选择排序、插入排序
Jakob_Hu的博客
05-20 282
选择排序、插入排序概述选择排序算法概述算法实现算法时间复杂度与稳定性插入排序算法概述算法实现算法时间复杂度及稳定性 概述 将这两个排序算法一起讲解是因为这两个排序算法的共同特点是将需要排序的序列视为两部分。即已完成排序的部分和未完成排序的部分。每执行完一轮操作后，未完成排序的部分将得到的极值返回到完成排序的部分的末尾。 选择排序 算法概述 选择排序的工作原理具体如下， 首先在未排序的序列中寻找最...
【算法】选择排序和插入排序
Apol1o_的博客
03-25 235
1. 前言 本文是基于本人在《算法（第4版）》的学习过程中做的笔记 接下来会介绍两种简单的初级排序算法： 选择排序 插入排序 首先是接下来要学习的排序算法的一套通用模板 /** 排序算法模板 **/ public class Example { public static void sort(Comparable[] a) {//具体算法见下文 } private static...
秒懂插入排序与选择排序
lzw刘仔很忙的博客
12-30 269
插入排序原理：它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。 插入排序核心：假设第一个元素排好，之后的元素对排好的部分从后向前比较并逐一移动。 插入排序实现： [cpp] view plain copy void insertion_sort(int a[], int n)
Java算法之 排一亿个随机数需要多久! (插入排序的多种实现方式及其图解)
qq_45596525的博客
11-14 1052
文章目录前言一、直接插入排序1. 图解插排2. 代码实现3.性能检测与时空复杂度 前言 插入排序狭义上指的是简单插入排序(选择集合,比较大小,插入元素),广义上还应该包括希尔排序(分治思想)及其两种实现方式,下面将介绍这几种排序方式及其同异点 提示：以下是本篇文章正文内容，下面案例可供参考 一、直接插入排序 1. 图解插排 思路 : 字面意义,插入是将某一元素按某种规则放入到特定集合中 ,因此我们需要将序列划分成为两块 ,一部分为有序集合, 另一部分为待排序集合 图解 : 为了方便理解,我们就按最最
75从零开始学Java之排序算法中的直接插入、快排和希尔排序
最新发布
一一哥
05-29 1056
在上一篇文章中，壹哥给大家介绍了冒泡排序和选择排序，这两种算法都是排序算法。实际上排序算法还有插入、希尔、快速排序等，接下来我们就来学习一下这几种排序算法。前戏已做完，精彩即开始全文大约【5400】字，不说废话，只讲可以让你学到技术、明白原理的纯干货！本文带有丰富的案例及配图视频，让你更好地理解和运用文中的技术概念，并可以给你带来具有足够启迪的思考......接下来我们把插入排序的特性总结一下。
26从零开始学Java之如何对数组进行排序与二分查找？
一一哥
04-28 1581
在上一篇文章中，壹哥给大家讲解了数组的扩容、缩容及拷贝方式。接下来在今天的文章中，壹哥会给大家讲解更重要的数组排序及查找方法。今天的内容会有点难，希望你不要因此而退缩，挺过这一关，你会向上突破的！前戏已做完，精彩即开始全文大约【3500】字，不说废话，只讲可以让你学到技术、明白原理的纯干货！本文带有丰富案例及配图视频，让你更好地理解和运用文中的技术概念，并可以给你带来具有足够启迪的思考......Java中的数组是一种数据集合，里面可以存储若干数据元素。
java实现排序(1)-插入排序
brickworkers的博客
04-19 959
引言排序模块会把所有的排序算法都整理一遍，方便自己以后回身学习。在本篇博文中主要介绍了时间复杂度为O(N^2)的插入排序算法，并用demo进行实现。不过在开始之前需要学习一些基础的数学知识，希望对大家有所帮助。笔者目前整理的一些blog针对面试都是超高频出现的。
选择排序和插入排序及比较-排序-算法第4版
gaogzhen的博客
09-23 422
文章目录一、选择排序1、算法描述2、分析3、特点3、代码实现二、插入排序1、算法描述2、分析3、代码实现4、总结三、两种排序算法的比较1、比较步骤2、代码实现 一、选择排序 1、算法描述 首先，找到数组中的最小的元素 其次，将它与数组的第一个元素交互位置 再次，在剩余的数组元素中找到最小的元素，将它与数组的第二个元素交互位置 如此重复，直到将整个数组排序 2、分析 比较元素：比较当前元素与目前已知的最小元素（以及将当前索引加1和检测是否代码越界） 交互元素：每轮只交互一个元素，因此交换的总次数是N（数
什么是选择排序？
mukewangguanfang的博客
01-12 4632
选择排序（Select Sort），是计算机科学与技术领域中较为简单的一种排序算法。假设我们按照从小到大的顺序进行排序。选择排序会首先从待排序序列中选择一个最小的元素放入排序好的序列中，然后依次在从未排序好的序列中选择最小的元素，直到最后需要选择的待排序序列中只有一个元素，只需要将这个元素放在最后位置，就完成了整个排序过程。
选择排序详解（Selection sort）
Wzill
05-12 1万+
1、第一次排序：用第一个元素和后面的元素进行对比，2和8对比，8比2大继续向后对比，然后2和1对比，1比2小，拿1继续向后比。用第二个元素8和后面的元素进行对比，8和2对比，2比8小，拿2和后面的元素进行对比。选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小元素，然后放到已排序的序列的。
【算法与数据结构】之选择排序
qq_45703196的博客
11-23 1191
1.直接选择排序 ①定义: 选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。 ②时间复杂度、空间复杂度和稳定性 时间复杂度：平均情况O(n2)，最坏情况O(n2) 空间平均情况：O(1) 稳定性：不稳定 ③代码 public class SelectionSort { public static void main(String[] arg
选择排序详解
云杉木屋
03-08 5065
摘要：选择排序算法是一种比较容易理解的排序算法，记得我在第一次学习C语言的时候，老师让我们自己尝试写一个排序，我们很多人下意识写出来的就是一种具有选择排序思想的排序算法，只不过那种算法会花费一个额外的数组进行存储，在学习了选择排序算法之后，我知道了那个数组是没有必要声明的
插入排序（算法导论中的伪代码实现）
qq_52659550的博客
07-22 3233
JAVA 及 Python插入排序（算法导论中的伪代码实现）
选择排序（超详细）
热门推荐
hcz666的博客
08-23 2万+
详细介绍选择排序
选择排序和插入排序的区别
Cookie1997的小屋
03-08 3076
很多人在学排序算法时，都接触到选择排序法和插入排序法，然而很多人对这两个排序法，分别是怎样的，又有什么细微的区别，却不了解。选择排序原理：主要在选择上，每一次从无序队列中选择出最小值，然后将其放置在有序队列的末尾，然后在无序队列中将其删除。插入排序原理：默认第一个元素为有序，后面的逐个向有序中插入，特点就是不断的移动数据，一直到排出序列。...
选择排序
梦想飞舞的专栏
08-17 296
php 数据结构 选择排序
Java Set详解：实现原理与选择指南
这篇文章将探讨Set如何确保元素唯一性，以及不同类型的Set实现类的特点和适用场景。 1. 元素唯一性的实现 Java中Set保证元素唯一性的方法主要是通过 equals() 和 hashCode() 方法。当尝试向Set中添加新元素时，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值