算法笔记04 - 选择排序 | 插入排序 | 冒泡排序 | 对数器检验

最新推荐文章于 2026-08-23 23:59:10 发布

原创最新推荐文章于 2026-08-23 23:59:10 发布 · 406 阅读

10 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

算法学习

选择排序

选择排序的时间复杂度O(n^2)

具体实现是：给定一个长度为n的数组，i从0开始一直到n-1，在i位置到n-1上遍历找到最小值，将最小值与i位置的值交换

这样一轮下来从0到n-1就是升序的了

代码实现：

    // 选择排序的实现
    public static void selectSort(int[] nums){
        // 处理边界条件
        if (nums == null || nums.length < 2) {
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            int minIndex = i;
            // 找到i -- n-1 位置上最小的数
            for (int j = i + 1; j < nums.length; j++) {
                minIndex = nums[minIndex] <  nums[j] ? minIndex : j;
            }
            swap(nums, i, minIndex);
        }
    }

插入排序

时间复杂度O(n^2)

具体实现：i从0开始到n-1自增，依次让[0,i]范围上有序，i自增后新出现的数依次跟左边的数比较（因为其左侧已经有序），如果比左边的数要小则交换，直到不再小，然后i继续自增

例如：[ 0, 1, 2, 6, 7, 4 ]

现在i已经进行到 i = 4，也就是在[0,4]位置上已经是有序的了[01267]，现在i自增，新出现的数是4，4比7小左移 -> [0, 1, 2, 6, 4, 7]，4比6小左移 -> [0, 1, 2, 4, 6, 7]，4不比2小则停止，此时就有序了

代码实现：

    public static void insertSort(int[] nums){
        if (nums == null || nums.length < 2) {
            return;
        }
        for (int i = 0; i < nums.length; i++) {	// 0 - i 范围变有序
            int curIndex = i;	// 新增的数
            // 第一个条件大于0，使得左移最多到数组开头
            // 第二个条件是比左边的数小
            while (curIndex > 0 && nums[curIndex] < nums[curIndex - 1]){
                swap(nums, curIndex, curIndex - 1);
                curIndex--;
            }
        }
    }

还可以将while函数写得更简便：

    //插入排序优化
    public static void insertSort2(int[] nums){
        if (nums == null || nums.length < 2) {
            return;
        }
        for (int i = 1; i < nums.length; i++) {
            for (int pre = i - 1; pre >= 0 && nums[pre] > nums[pre + 1]; pre--){
                swap(nums, pre, pre + 1);
            }
        }
    }

冒泡排序

时间复杂度O(n^2)

具体实现：i从n-1开始，0 – i范围上，相邻位置依次比较，若前一项比后一项大就交换，最后最大值来到i位置；然后再从0 – i-1范围上继续，依次进行到有序。

代码实现：

    //冒泡排序
    public static void popSort(int[] nums){
        if (nums == null || nums.length < 2) {
            return;
        }
        for (int maxTail = nums.length - 1; maxTail > 0; maxTail--) {
            int curMaxIndex = 0;
            while (curMaxIndex != maxTail){
                if (nums[curMaxIndex] > nums[curMaxIndex + 1]){
                    swap(nums, curMaxIndex, curMaxIndex + 1);
                } else {
                    curMaxIndex++;
                }
            }
        }
    }

三种算法的对数器验证

什么是对数器？

对数器是测试一个算法的工具，通过随机生成超大量的测试案例，来覆盖所有情况，如果算法能通过这些所有测试案例则说明写对了，这是自我检验算法最重要的工具。

同时通过对数器，我们可以控制测试案例的长度，让我们在出错时能快速找到是什么问题。

对数器的常用步骤：

1，你想要测的方法a（最优解）

2，实现复杂度不好但是容易实现的方法b（暴力解）

3，实现一个随机样本产生器（长度也随机、值也随机）

4，把方法a和方法b跑相同的输入样本，看看得到的结果是否一样

5，如果有一个随机样本使得比对结果不一致，打印这个出错的样本进行人工干预，改对方法a和方法b6，当样本数量很多时比对测试依然正确，可以确定方法a（最优解）已经正确。

对三种排序算法的检验

可以通过传统方法：用自己写得排序算法排一次测试案例，再用Arrays.sort()方法排一次，对比两个数组是否完全相等，相等则正确，不相等就错误

这里我用一个简单的函数判断是否有序

    public static boolean isSorted(int[] arr){
        for (int i = 1; i < arr.length; i++){
            if (arr[i] < arr[i - 1]){
                return false;
            }
        }
        return true;
    }

然后是生成随机数组的函数（随机样本生成器）

传入一个最大值和数组的最大长度

Java里面Math.random()能随机生成[0, 1)的数字，因此×一个n并强转位整数则能随机生成[0, n-1]

    // 生成随机数组检验
    public static int[] getRandomArray(int maxValue, int maxLen){
        int len = (int)(Math.random() * maxLen);

        int[] arr = new int[len];
        for (int i = 0; i < len; i++) {
            arr[i] = (int)(Math.random() * maxValue);
        }

        return arr;
    }

测试的主体：

    public static void main(String[] args) {

        //测试案例
        int test_times = 100000;
        int maxLen = 100;
        int maxValue = 500000;

        //1
        for (int i = 0; i < test_times; i++) {
            int arr[] = getRandomArray(maxValue,maxLen);
            selectSort(arr);
            if (isSorted(arr)) {
            } else{
                System.out.println("选择排序有问题！");
                break;
            }
        }
        System.out.println("选择排序的结果全部正确！");

        //2
        for (int i = 0; i < test_times; i++) {
            int arr[] = getRandomArray(maxValue,maxLen);
            insertSort2(arr);
            if (isSorted(arr)) {
            } else{
                System.out.println("插入排序有问题！");
                break;
            }
        }
        System.out.println("插入排序的结果全部正确！");

        //3
        for (int i = 0; i < test_times; i++) {
            int arr[] = getRandomArray(maxValue,maxLen);
            popSort(arr);
            if (isSorted(arr)) {
            } else{
                System.out.println("冒泡排序有问题！");
                break;
            }
        }
        System.out.println("冒泡排序的结果全部正确！");
    }