常用的排序方法

1. 冒泡排序：

        这是一种简单的排序算法，它重复地遍历待排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

# 1. 定义函数, 表示冒泡排序.
def bubble_sort(my_list):
    # 定义变量, 记录: 列表的长度.
    n = len(my_list)
    # 开始排序, 遍历.  外循环充当: 比较的轮数
    for i in range(0, n - 1):        
        count = 0

        # 内循环, 充当: 每轮比较的次数.
        for j in range(0, n - i - 1): 
            # 具体的比较过程. j 和 j + 1的元素对比.
            if my_list[j] > my_list[j + 1]:
                # 走这里, 是具体的交换动作.
                count += 1      # 表示交换1次.
                my_list[j], my_list[j+1] = my_list[j+1], my_list[j]

        # 如果count是0, 说明已经是最终排序结果了, 无需交换, 结束即可.
        if count == 0:
            break

# 2. 在main方法中测试.
if __name__ == '__main__':
    # 3. 定义列表, 记录: 要排序的元素.
    # my_list = [11, 33, 55, 22, 44]
    my_list = [11, 22, 33, 44, 55]
    print(f'排序前: {my_list}')
    # 4. 调用 排序算法, 对列表元素排序.
    bubble_sort(my_list)
    # 5. 打印排序结果.
    print(f'排序后: {my_list}')

2. 选择排序：

        在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。

# 1. 定义函数, 表示选择排序.
def select_sort(my_list):
    # 获取列表长度.
    n = len(my_list)   
    # 外循环, 控制: 比较的轮数
    for i in range(0, n - 1):                   
        # 定义变量 min_index, 用来表示最小值的索引.
        min_index = i   
        # 内循环, 控制每轮比较的次数.
        for j in range(i + 1, n):             
            # 1.5 具体的比较过程, 如果 j对应的元素 比 min_index对应的元素小, 就将j的值赋值给min_index
            if my_list[j] < my_list[min_index]:
                min_index = j       # min_index 永远记录: 最小值所在的位置(索引)

        # 判断min_index的值是否有修改, 如果有修改, 说明最小值有变动, 交换即可.
        if min_index != i:
            my_list[i], my_list[min_index] = my_list[min_index], my_list[i]

# 2. 在main方法中测试.
if __name__ == '__main__':
    # 3. 定义列表, 记录: 要排序的元素.
    my_list = [11, 33, 55, 22, 44]
    print(f'排序前: {my_list}')
    # 4. 调用 排序算法, 对列表元素排序.
    select_sort(my_list)
    # 5. 打印排序结果.
    print(f'排序后: {my_list}')

3. 插入排序：

        将未排序数据按其排序码依次插入到已排序数据的合适位置，直到所有数据均插入到数组中。

# 1. 定义函数, 实现: 插入排序.
def insert_sort(my_list):     
    
    # 获取列表的长度.
    n = len(my_list)
    # 通过外循环, 表示: 有序列表(中的每个值)             
    for i in range(1, n):
        # 通过内循环, 依次从无序列表中逐个获取每个值, 然后和 有序列表的(每个)值进行比较.  
        for j in range(i, 0, -1):   
            # 如果 无序列表的值 小于 有序列表的值, 就交换.
            if my_list[j] < my_list[j - 1]:
                # 具体交换过程.
                my_list[j], my_list[j - 1] = my_list[j - 1], my_list[j]
            else: 
                break

# 2. 在main方法中进行测试.
if __name__ == '__main__':
    # 定义列表, 记录要排序的数据.
    my_list = [11, 33, 22, 55, 44]
    # 打印排序前的结果.
    print(f'排序前: {my_list}')
    # 排序
    insert_sort(my_list)
    # 打印排序后的结果.
    print(f'排序后: {my_list}')

4. 快速排序：

        通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

# 1. 定义函数, 实现: 快速排序.
def quick_sort(my_list, start, end):      
    # 递归出口, 只要start >= end, 说明排好顺序了, 程序结束.
    if start >= end:
        return
    # 定义分界值, 假定第1个元素为分界值.
    mid = my_list[start]    # 默认: mid = my_list[0]
    # 定义游标, 表示左边的 和 右边的数据.
    left = start
    right = end

    # 通过循环, 获取到(列表)每个数据.
    while left < right:
        # 将大于或等于分界值的数据集中到数组右边，
        while my_list[right] >= mid and left < right:
            right -= 1
        
        my_list[left] = my_list[right]
        # 小于分界值的数据集中到数组的左边
        while my_list[left] < mid and left < right:
            left += 1
        my_list[right] = my_list[left]

    # 循环结束后, 说明: 分界值的位置找到了.
    my_list[left] = mid
    # 将该部分数据分成左右两部分，同样在左边放置较小值, 右边放置较大值, 右侧的数组数据也做类似处理
    # 处理分界后, 左边的数据(即: 比分界值小的数据)
    quick_sort(my_list, start, left - 1)
    # 处理分界后, 右边的数据(即: 比分界值大的数据)
    quick_sort(my_list, right + 1, end)

# 2. 在main方法中进行测试.
if __name__ == '__main__':
    # 定义列表, 记录要排序的数据.
    my_list = [11, 33, 22, 55, 44]
    # 打印排序前的结果.
    print(f'排序前: {my_list}')
    # 排序
    quick_sort(my_list, 0, len(my_list) - 1)
    # 打印排序后的结果.
    print(f'排序后: {my_list}')