简单O(n^2)排序-冒泡、选择、直接插入、二分插入排序（Java实现）

最新推荐文章于 2024-05-18 16:42:38 发布

Baage-cn

最新推荐文章于 2024-05-18 16:42:38 发布

阅读量145

点赞数

分类专栏：算法文章标签： java 排序算法算法

本文链接：https://blog.csdn.net/leryi/article/details/126196534

版权

算法专栏收录该内容

8 篇文章 0 订阅

订阅专栏

活动地址：CSDN21天学习挑战赛

1.冒泡排序

自低向上依次比较，通过交换，使当前元素始终未最大值，直到未排序部分的末尾完成一次冒泡

void sort(int[] nums)

1.1 算法分析

冒泡排序应该是我们最早接触的算法之一了，之所以称为冒泡排序，就是因为他的特性和冒泡十分的相似，其每次冒泡的过程，随着水泡的上升，其体积也会越来越大。从代码层次解释就是从第1个元素开始，与其下一个元素进行比较，选出一个较大的元素放到后面，然后再拿这个元素与后面的元素进行比较，直到比较到未排序的数组末尾，然后将其设置为已排序的元素，进行下一轮冒泡，直到只有一个泡泡（一定为最小了）为止。

1.2 代码实现

public void sort(int[] nums) {
    // 对[1, nums.length) 进行冒泡选取
    for (int end = nums.length - 1; end >= 1; end--) {
        // 选取第end处的最大元素
        for (int begin = 1; begin <= end; begin++) {
            if (nums[begin] < nums[begin - 1]) {
                int tmp = nums[begin];
                nums[begin] = nums[begin - 1];
                nums[begin - 1] = tmp;
            }
        }
    }
}

1.3 复杂度分析

时间复杂度：两层for循环都与数据nums的长度n有关，故时间复杂度为O(n^1)
空间复杂度：没有引入新的空间，O(1)

2.选择排序

从未排序的序列中选取一个最大的元素放到未排序的序列的末尾

void sort(int[] nums)

2.1 算法分析

选择排序可以看作是冒泡排序的一种升级，其每次选择也和冒泡排序的目的相同，都是将当前剩余元素的最大元素放到末尾，与冒泡不同的是，其在比较时发现较大的元素时不需要进行交换，而只需要进行记录，最后在进行交换即可

2.2 代码实现

public sort(int[] nums) {
    for (int end = nums.length - 1; end >= 1; end--) {
        int maxIndex = 0;
        for (int begin = 1; begin <= end; begin++) {
            if (nums[begin] > nums[maxIndex]) {
                // 只是做了记录，不进行交换，相对冒泡排序，减少了时间复杂度
                maxIndex = begin;
            }
        }
        // 选出最大的元素后，与末尾进行交换
        int tmp = nums[maxIndex];
        nums[maxIndex] = nums[end];
        nums[end] = tmp;
    }
}

2.3 复杂度分析

时间复杂度：同冒泡排序，只不过减少了交换次数，但依旧是O(n^2)
空间复杂度：只使用了一个maxIndex变量用来记录最大值的下标，所以空间复杂度为O(1)

3.插入排序

将待排序序列的第一个元素，插入到已排序序列的合适位置

void sort(int[] nums)

3.1 算法分析

插入排序类似于打扑克，其将序列分为两部分，第一部分为有序部分，第二部分为无序（未排序）部分，如下所示，每次从待排序部分选出第一个元素，依次与已排序序列的元素（从右往左）进行比较，选出一个合适的位置进行插入，如下，52将依次与96、94、82、61、51进行比较，最后发现51比52小，就将其插入到51后。

在这里插入图片描述

3.2 代码实现

public void sort(int[] nums) {
    // 对第 i 个元素进行插入
    for (int i = 1; i < nums.length; i++) {
        // 使用cur记录
        int cur = nums[i];
        // 将第 i 个元素与第j个元素进行比较
        int j = i -1;
        for (; j >= 0; j--) {
            if (cur < nums[j]) {
                nums[j + 1] = nums[j];
            } else {
                break;
            }
        }
        nums[j + 1] = cur;
    }
}

3.3 复杂度分析

时间复杂度：两层与n相关的循环结构，故时间复杂度为O(n^2)
空间复杂度：O(1)

3.4 优化方案

通过观察，我们可以发现，对于插入元素寻找合适位置的操作其实就是一个查找的操作，而常用的查找方式就是顺序查找和二分查找，而我们之前使用的查找显然是一个顺序查找，所以查找的时间复杂度为O(n)，然而我们前面的序列是有序的，所以我们完全可以使用二分查找，来将查找的时间复杂度降低到O(logn)级别,实现如下:

    public static void sort2(int[] nums) {
        // 对第 i 个元素进行插入
        for (int i = 1; i < nums.length; i++) {
            int cur = nums[i];
            int left = 0;
            int right = i;
            // 依然设设置为左闭右开即，[left, right),所以当 right-left=0时结束循环
            while(left < right) {
                int mid = (left + right) / 2;
                // 分治
                if (nums[mid] > cur) {
                    right = mid;
                } else {
                    left = mid + 1;
                }
            }
            // 将获取到的位置以后的元素整体往后移动一个位置
            for (int j = i - 1; j >= left; j--) {
                nums[j + 1] = nums[j];
            }
            // 对移动后空出的位置进行插入新的元素
            nums[left] = cur;
        }
    }

这里左边界和右边界依旧使用的是左闭右开的形式，前面说过这样设计可以通过相减获取剩余元素数量，而现在我们这样设计又会带来一个好处，那就是更容易获取到临界位置，首先，我先说一下结论(在二分查找基础上)：

对于正序序列，如果要获取第一个比待查元素值小的元素的位置，只需设置元素相同时向左移动 right
对于正序序列，如果要获取第一个比待查元素值大的元素的位置，只需设置元素相同时向左移动 left

最后，我们再来说一下优化后的时间复杂度，很遗憾，优化后的插入排序时间复杂度仍然为 O(n^2)，这是因为我们还需要考虑元素的移动问题，通过二分查找找到下一个要插入的元素位置，确实可以在 O(logn) 的时间内完成。但是两个前提，一个是前面已排序的序列需要满足call-by-rank（能够从下标读取），另一个是可以直接插入，我们常用的存储方式如数组，就可以完成下标读取，但不能直接插入。所以如果我们将数插入有序序列，那么该元素后面的数均需要往后移动一个单位，如果运气不好，这是最小的一个数，那么子序列所有元素都要往后移动，这个操作复杂度为O(logn)，2 * O(logn) = O(logn) 所以其实并不能减少复杂度。