Python算法——排序算法（冒泡、选择、插入、快速）

本文章只展示代码实现 ，原理大家可以参考：

https://zhuanlan.zhihu.com/p/42586566

一、冒泡排序

def bubble_sort(lst):
 
    for i in range(len(lst) - 1):  # 表示第i趟
 
        exchange = False  # 每一趟做标记
 
        for j in range(len(lst)-i-1):  # 表示箭头
 
            if lst[j] > lst[j+1]: # 此时是升序排序，>改为<则改为了降序
 
                lst[j],lst[j+1] = lst[j+1],lst[j]
 
                exchange = True  # 进行了交换，exchange标记为Ture
 
        print(f"第{i+1}趟后的列表为：{lst}")  # 查看排序过程
 
        if not exchange: # 如果没有进行交换，直接返回，优化的步骤
 
            return
 
lst2 = [1,2,3,8,7,6,5]
 
print("***改进后的冒泡排序***")
 
print(f"初始列表:{lst2}")
 
bubble_sort(lst2)
 
# 输出结果
 
# 初始列表:[1, 2, 3, 8, 7, 6, 5]
 
# 第1趟后的列表为：[1, 2, 3, 7, 6, 5, 8]
 
# 第2趟后的列表为：[1, 2, 3, 6, 5, 7, 8]
 
# 第3趟后的列表为：[1, 2, 3, 5, 6, 7, 8]
 
# 第4趟后的列表为：[1, 2, 3, 5, 6, 7, 8]

二、选择排序

def select_sort(lst):
 
    for i in range(len(lst) - 1):  # i代表第几趟
 
        min_location = i # 最小位置的标记，第一次默认最小的数为无序区的第一个，即下标为i
 
        for j in range(i+1,len(lst)): # 从i开始相当于自己和自己比了一次，此步骤多余，因此从i+1开始
 
            if lst[j] < lst[min_location]:
 
                min_location = j
 
        lst[i],lst[min_location] = lst[min_location],lst[i] # 最小的值和有序区的最后一个值进行交换
 
        print(f"第{i + 1}趟后的列表为：{lst}")
 
 
 
 
 
lst1 = [3,2,4,13,11,8]
 
select_sort(lst1)
 
# 结果
 
# 第1趟后的列表为：[2, 3, 4, 13, 11, 8]
 
# 第2趟后的列表为：[2, 3, 4, 13, 11, 8]
 
# 第3趟后的列表为：[2, 3, 4, 13, 11, 8]
 
# 第4趟后的列表为：[2, 3, 4, 8, 11, 13]
 
# 第5趟后的列表为：[2, 3, 4, 8, 11, 13]

三、插入排序

def insert_sort(lst):
 
    for i in range(1,len(lst)):  # i表示摸到的牌的下标
 
        tmp = lst[i] # tmp代表摸到的牌
 
        j = i - 1 # j代表的是手里的牌的下标，手上自动已有第一张牌
 
        while lst[j] > tmp and j >= 0: # 需要移动有序区牌的情况
 
            lst[j+1] = lst[j]
 
            j -= 1
 
        lst[j+1] = tmp  # lst[j+1]是用来存放要插入的牌
 
        print(f"第{i}趟的列表：{lst}")
 
 
 
lst1 = [3,2,5,8,6,9,7]
 
print(f"原列表{lst1}")
 
insert_sort(lst1)
 
# 结果原列表[3, 2, 5, 8, 6, 9, 7]
 
# 第1趟的列表：[2, 3, 5, 8, 6, 9, 7]
 
# 第2趟的列表：[2, 3, 5, 8, 6, 9, 7]
 
# 第3趟的列表：[2, 3, 5, 8, 6, 9, 7]
 
# 第4趟的列表：[2, 3, 5, 6, 8, 9, 7]
 
# 第5趟的列表：[2, 3, 5, 6, 8, 9, 7]
 
# 第6趟的列表：[2, 3, 5, 6, 7, 8, 9]

四、快速排序

def partition(lst,left,right):  # partition(分割)函数
 
    tmp = lst[left]  # 存放基准点，以最左边的值为例
 
    while left < right:  # 当左边的位置（下标）小于右边的时候，说明还有至少两个元素，则进行排序
 
        while lst[right] >= tmp and left < right:  # 从右边找比tmp小的元素
 
            right -= 1  # 比tmp大，则往左移动一位
 
        lst[left] = lst[right]  # 如果出现lst[right] < tmp，则将右边的值lst[right]写到左边的空位lst[left]
 
        # print(f"从右边找比tmp小的数后的列表:{lst}")
 
        while lst[left] <= tmp and left < right:  # 从左边找比tmp大的元素lst[left]，放到右边的空位上lst[right]
 
            left += 1
 
        lst[right] = lst[left]
 
        # print(f"从左边找比tmp大的数后的列表:{lst}")
 
    lst[left] = tmp  # 最后把tmp归位
 
    return left  # 返回mid的值
 
 
 
# lst1 = [5,7,4,2,6,8,3,1,9]
 
# print(f"分割前的列表{lst1}")
 
# partition(lst1,0,len(lst1)-1)
 
# print(f"最终tmp归为后的列表:{lst1}")
 
# 输出结果
 
# 分割前的列表[5, 7, 4, 2, 6, 8, 3, 1, 9]
 
# 从右边找比tmp小的数后的列表:[1, 7, 4, 2, 6, 8, 3, 1, 9]
 
# 从左边找比tmp大的数后的列表:[1, 7, 4, 2, 6, 8, 3, 7, 9]
 
# 从右边找比tmp小的数后的列表:[1, 3, 4, 2, 6, 8, 3, 7, 9]
 
# 从左边找比tmp大的数后的列表:[1, 3, 4, 2, 6, 8, 6, 7, 9]
 
# 从右边找比tmp小的数后的列表:[1, 3, 4, 2, 6, 8, 6, 7, 9]
 
# 从左边找比tmp大的数后的列表:[1, 3, 4, 2, 6, 8, 6, 7, 9]
 
# 最终tmp归为后的列表:[1, 3, 4, 2, 5, 8, 6, 7, 9]
 
 
 
# 随后完成快速排序主体部分的代码
 
def quick_sort(lst, left, right):  # 需要传入一个列表lst，以及最左边后最后边的位置
 
    if left < right:  # 如果左边小于右边，则说明列表内至少有两个元素
 
        mid = partition(lst, left, right)  # 通过partition获得基准值mid
 
        quick_sort(lst, left, mid - 1)  # 递归左边的元素
 
        quick_sort(lst, mid + 1, right)  # 递归右边的元素
 
 
 
 
 
lst2 = [5,7,4,2,6,8,3,1,9]
 
print(f"初始列表:{lst2}")
 
quick_sort(lst2,0,len(lst2)-1)
 
print(f"快速排序后的{lst2}")
 
# 输出结果
 
# 初始列表:[5, 7, 4, 2, 6, 8, 3, 1, 9]
 
# 快速排序后的[1, 2, 3, 4, 5, 6, 7, 8, 9]