【Python数据结构与算法】（五）排序算法（上）：冒泡、选择、插入

【Python数据结构与算法】（五）排序算法（上）：冒泡、选择、插入

• ✨本文收录于《Python数据结构与算法》专栏，此专栏主要记录如何python学习数据结构与算法笔记。
• 🌸个人主页：JoJo的数据分析历险记
• 📝个人介绍：小编大四统计在读，目前保研到统计学top3高校继续攻读统计研究生
• 💌如果文章对你有帮助，欢迎✌关注、👍点赞、✌收藏、👍订阅专栏

排序算法

上一章介绍了基本的查找方法，其中，在介绍二分查找时，我们假定列表是一个有序的，那么如果是无序的呢？我们首先需要对其进行排序。排序：将一组无序的记录序列调整为有序的记录序列。python中内置的排序函数是sort()。本章介绍排序中的最基础三种方法：冒泡排序，选择排序，插入排序

1. 冒泡排序

1.1基本原理

遍历列表排序，比较列表每相邻的两个数，如果他们的位置错误，则交换。以升序为例：

• 如果前面的数比后面的数大，则交换这两个数
• 排序完成后，无序区减少一个数，有序区增加一个数
• 重复知道不需要交换，表明已经排序完成

具体如下，我们第一次排序，将93正确排序到了相应的位置，此时就不再进行排序了，进入有序区

具体实现过程如下图所示：

下面我们思考一下如何写代码，上面是进行了一趟排序。我们可以看出一共有两个循环，外面的循环是趟数，内部的循环是遍历无序区进行排序。那么我们一共只需要进行n-1趟就可以完成。无序区的范围是$(0,n-1-i)$。代码关键：趟、无序区范围。

1.2 代码分析

基础代码：

def bubble_sort(li):
    for i in range(len(li)-1):#定义排序的趟数
        for j in range(len(li)-i-1):#定义无序区的范围
            if li[j] > li[j+1]:#如果前面的数大于后面的数，则交换位置
                li[j+1],li[j] = li[j],li[j+1]
        print('第%s趟:' % i, li)

分析：

• 当列表已经是排好序的时候，那么它根本不需要交换。但是，上述代码进行了很多没有意义的操作。下面我们考虑一下如何进行优化。
• 当在某一趟排序时候，如果没有任何交换，则停止排序。此时列表已经排好序了。下面我们来看看具体如何写详细的代码

优化后的代码

def bubble_sort2(li):
    for i in range(len(li)-1):
    	exchange = True
        for j in range(len(li)-1-i):
            if li[j] > li[j+1]:
                li[j],li[j+1] = li[j+1],li[j]
                exchange = False
    	print('第%s趟:' % i, li)
        if exchange:#如果没有交换，则直接跳出循环
            break

我们现在来看看优化前后代码结果：

li = [1,3,4,2,5,6]
print('-------基础代码--------')
bubble_sort(li)
li = [1,3,4,2,5,6]
print('-------优化后代码-------')
bubble_sort2(li)

-------基础代码--------
第0趟: [1, 3, 2, 4, 5, 6]
第1趟: [1, 2, 3, 4, 5, 6]
第2趟: [1, 2, 3, 4, 5, 6]
第3趟: [1, 2, 3, 4, 5, 6]
第4趟: [1, 2, 3, 4, 5, 6]
-------优化后代码-------
第0趟: [1, 3, 2, 4, 5, 6]
第1趟: [1, 2, 3, 4, 5, 6]
第2趟: [1, 2, 3, 4, 5, 6]

可以看出，优化后，代码运行次数减少了。

1.3 小结

冒泡排序的基本属性如下：

• 具有稳定性：冒泡排序具有稳定性，当列表具有重复值时，他们的相对位置不变,例如2,1,2,3,第一个2，排序之后还是在第二个2前面。
• 时间复杂度为：$O(N^2)$
• 具有适应性：当数组已经接近排好序时，时间复杂度为$O(n)$

2. 选择排序

2.1 基本原理

选择排序的基本思想是，每次都选择最小的元素。因此需要定义一个最小元素的索引：min_loc，如果后面的元素有小于当前元素的，则交换与min_loc的位置。具体步骤如下；

• 首先我们定义最小的元素就是无序区的第一个元素
• 遍历无序区元素和定义的最小元素比较，如果小于定义的最小元素，则交换。

具体过程如下图所示。

2.2 代码分析

下面我们来看看如何写具体的代码。首先和冒泡排序一样，也需要进行两次for循环，第一次是趟数，第二次是遍历整个无序区。具体代码如下：

def select_sort(li):
    for i in range(len(li)-1):#第i趟
        min_loc = i#首先定义一个最小元素的索引，假设为无序区的第一个元素
        for j in range(i,len(li)):#无序区范围
            if li[j]<li[min_loc]:
                min_loc = j#得到最小数的下标
        li[min_loc],li[i] = li[i],li[min_loc]#完成交换
        print("第%s趟"%i,li)
li = [3,2,4,1,5,6]
select_sort(li)        

2.3 小结

选择排序的基本属性如下：

• 不具有稳定性
• 时间复杂度为：$O(N^2)$
• 不具有适应性

3. 插入排序

3.1 基本原理

大家肯定都玩过扑克牌，插入排序的基本思想就和模扑克牌一样，每次摸一张牌，与有序区中的最后一个元素开始比较，向右移动直到当前摸到的牌位置正确，如下图所示：

可以看出首先也是需要一个for循环来代表趟数，但是内部此时需要一个While循环，来判断插入的位置。通过下面这张动图来更好理解插入排序：

3.2 代码分析

现在我们来看一下具体的代码应该如何写

def insert_sort(li):
    for i in range(1, len(li)):#遍历多少趟,i表示摸到牌的下标
        tmp = li[i]
        j = i-1 #表示手里的最后一张牌的下标
        while li[j] > tmp and j>=0:#手里要有牌，并且摸到的牌
            li[j+1] = li[j]
            j -= 1
        li[j+1] = tmp
        print('第%s趟:'%i, li)
li = [3,2,4,1,6,5]
insert_sort(li)

第1趟: [2, 3, 4, 1, 6, 5]
第2趟: [2, 3, 4, 1, 6, 5]
第3趟: [1, 2, 3, 4, 6, 5]
第4趟: [1, 2, 3, 4, 6, 5]
第5趟: [1, 2, 3, 4, 5, 6]

3.3 小结

插入排序的基本属性如下：

• 具有稳定性
• 时间复杂度：$O(n^2)$
• 具有适应性

总结

🚝本章介绍了排序算法中最基础的三个方法：冒泡排序、选择排序、插入排序。这三种排序方法的时间复杂度都是$O(n^2)$,后续会介绍一些更高级的排序算法。

本章的介绍到此介绍，如果文章对你有帮助，请多多点赞、收藏、评论、关注支持！！