算法入门之lowB三人组---冒泡排序、选择排序、插入排序 【python版-详解】

目录

lowB三人组：

• 冒泡排序

• 选择排序

• 插入排序

冒泡排序

冒泡排序原理：将下标为0的a与后面的数进行比较大小，若a大，则将它们通过下标进行位置交换，一次循环过后，列表中最大的元素将会在最后一个，重复上述操作，每次遍历不需要将后面已经排好的有序元素进行比较（因为它们已经最大了）。

时间复杂度为O(n^2)，空间复杂度为O(1)，稳定

def bubble_sort(li):
    for i in range(len(li)-1):
        exchange = False	#  # exchange的作用：若已排序好，不需再进行多余排序遍历，减少时间
        for j in range(len(li)-i-1):
            if li[j] > li[j+1]:
                li[j], li[j+1] = li[j+1], li[j]
                exchange = True
        # print(li)
        if not exchange:
            return

li = [9,8,7,6,1,2,3,4,5]
print(li)
bubble_sort(li)
#  输出结果
#  [9, 8, 7, 6, 1, 2, 3, 4, 5]
#  [1, 2, 3, 4, 5, 6, 7, 8, 9]

选择排序

选择排序原理：设首元素为最小，将首元素与后面每个数进行比较大小，若首元素大，则将小的通过下标进行位置交换，一次循环下来，首元素为最小，即下标为0，接着将下标为1的元素与后面的数下标为(2,3…)的进行比较，重复上述操作，不断的将未排序中的最小数排到前面已排序列表中

写法一：该写法创建了一个新列表，并不是原地排序，如果列表长度过大，新增列表，min（），remove（）会增加时间复杂度

def select_sort_simple(li):
    for i in range(len(li)):  
        li_min = min(li)
        li_new.append(li_min)
        li.remove(li_min)


li_new = []
b = [3,1,9,8,6,5,2]
print(b)
select_sort_simple(b)
print(li_new)
#  输出结果
#  [3, 1, 9, 8, 6, 5, 2]
#  [1, 2, 3, 5, 6, 8, 9]

写法二：该写法 采用 原地排序，时间复杂度为O(n^2)，空间复杂度O(1)，不稳定。相比冒泡排序，每次循环只对最小值的下标进行改变，时间上有了很大的提升。

def select_sort(li):
    for i in range(len(li)-1):  # 第i次，第0次也算，左闭右开；假如列表长度为3，那么只需进行2次遍历可得结果（即i取0, 1）.同理长度n，需要进行n - 1次。
        exchange = False
        for j in range(i+1, len(li)):  # 下标i前面已经有序，后面无序需要将i与i+1比较，所以用i+1（i也可以但没必要），
            if li[i] > li[j]:
                li[i], li[j] = li[j], li[i]
                exchange = True
        # print(li)
        if not exchange:
            return

b = [9,8,7,6,1,2,3,4,5]
print(b)
select_sort(b)
print(b)
#  输出结果
#  [9, 8, 7, 6, 1, 2, 3, 4, 5]
#  [1, 2, 3, 4, 5, 6, 7, 8, 9]

插入排序

插入排序原理：我们设列表分为两个部分：已排序元素和未排序元素，设首元素为已排序元素，首元素后面的元素为未排序元素，将未排序元素逐个与前面已排序元素通过下标进行比较大小然后实现插入。

在最好的情况下，列表完全有序，只需插入一次，此时时间复杂度为O(n)。在最坏的情况下，列表完全逆序，也就是：每次插入都要插到已排序的第一位，此时时间复杂度为O(n^2)。

直接插入排序，时间复杂度O(n^2)，空间复杂度为O(1)，稳定。

相比冒泡排序，一般情况下，插入排序只需对未排序的一个元素进行插入赋值，比冒泡排序时间减少许多。

def insert_sort(li):
    for i in range(1,len(li)):
        tmp = li[i]
        j = i - 1
        while j >= 0 and li[j] > tmp:   # 若tmp足够小，当j=-1为终止条件；反之tmp为前面有序元素中的中间值，tmp<= li[j]为终止条件。
            li[j+1] = li[j]
            j -= 1
        li[j+1] = tmp   # 此时的j不是上面j=i-1的值，而是经历过while循环里面的j-=1的值。
        print(li)

b = [3,2,4,1,5,7,9,6,8]
print(b)
insert_sort(b)
"""
[3, 2, 4, 1, 5, 7, 9, 6, 8]
[2, 3, 4, 1, 5, 7, 9, 6, 8]
[2, 3, 4, 1, 5, 7, 9, 6, 8]
[1, 2, 3, 4, 5, 7, 9, 6, 8]
[1, 2, 3, 4, 5, 7, 9, 6, 8]
[1, 2, 3, 4, 5, 7, 9, 6, 8]
[1, 2, 3, 4, 5, 7, 9, 6, 8]
[1, 2, 3, 4, 5, 6, 7, 9, 8]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
"""

以上为本人见解，还有很多地方有待完善，若您有宝贵的建议，请欢迎指出！！！

若您对上述三种排序代码思路仍模糊，请您前往b站的**python版冒泡、选择、插入排序视频讲解**，我认为该视频讲的挺好的。