python数据结构：冒泡排序，选择排序，插入排序，希尔排序（进阶的插入排序），快速排序，归并排序

• 冒泡排序：

def bubble_sort(alist):
    """大的排后面"""
    n = len(alist)
    for j in range(n-1):
        count = 0
        for i in range(n-1-j):
            if alist[i] > alist[i+1]:
                alist[i], alist[i+1] = alist[i+1], alist[i]
                count += 1
        # 为了优化代码，减少复杂度
        if count == 0:
            break

if __name__ == '__main__':
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print(li)
    bubble_sort(li)
    print(li)

• 选择排序：

"""
选择一个数假定为最小值，依次向后比较，
遇到更小的就将游标指向该数，结束内层循环时，找到最小值
将其与第j位交换位置
"""
def select_sort(alist):
    n = len(alist)
    # 控制循环的次数，同时j也是假定的最小值的索引
    for j in range(n-1):
        min_index = j
        # 从假定最小值的后一位开始进行比较
        for i in range(j+1,n):
            if alist[i] < alist[min_index]:
                min_index = i
        if min_index != j:
            alist[min_index],alist[j] = alist[j],alist[min_index]


if __name__ == '__main__':
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print(li)
    select_sort(li)
    print(li)

• 插入排序和希尔排序（进阶的插入排序）：

"""
将列表分为两部分，一部分无序，一部分有序
在无序部分选择一个数，向前与有序部分进行比较，
如果比前一个小就交换位置，如果比前一个大，则退出循环
"""
def insert_sort(alist):
    # 列表第一个数视为有序的，
    for j in range(1, len(alist)):
        # 从有序部分之后，取一个数，向前比较
        for i in range(j, 0, -1):
            if alist[i] < alist[i - 1]:
                alist[i], alist[i - 1] = alist[i - 1], alist[i]
            else:
                break


def shell_sort(alist):
    n = len(alist)
    # 以gap为模，将列表分割为两部分，相差gap的数进行比较
    gap = n // 2
    # 当
    while gap >= 1:
        for j in range(gap, n):
            i = j
            # i-gap 即为j在另外一部分的对应位置
            while i - gap >= 0:
                # 小的放前面，大的放后面
                if alist[i] < alist[i - gap]:
                    alist[i], alist[i - gap] = alist[i - gap], alist[i]
                    i -= gap
                else:
                    break
        gap //= 2


if __name__ == '__main__':
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print(li)
    insert_sort(li)
    print(li)

    li2 = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print(li2)
    shell_sort(li2)
    print(li2)

• 快速排序：

"""
寻找一个基准值，从列表的两端开始，left += 1 ， right += 1
分别比较list[left] list[right] 与 基准值的大小，
基准值右侧放大的，左侧放小的
将基准值放在 left 的位置上
然后递归调用，分别对基准值两边进行 快速排序，直到 start >= end 时递归结束返回
"""
def quick_sort(alist, start, end):
    if start >= end:
        return
    mid = alist[start]  # 基准值
    left = start  # left在0
    right = end  # ringt在尾部
    while left < right:
        # 先右部,大于基准值的放在右部
        while alist[right] > mid and left < right:
            right -= 1
        # 结束时，得到一个小于基准值的数,放在左边
        alist[left] = alist[right]
        # 再左部，小于或等于基准值的放在左部
        while alist[left] <= mid and left < right:
            left += 1
        # 结束时，得到一个大于基准值的数,放在右边
        alist[right] = alist[left]
    # 外部循环结束时，left>=right ，此处存放基准值，左侧小，右侧大
    alist[left] = mid
    # 递归调用，分别对基准值两边的数值，进行快速排序
    # 左部
    quick_sort(alist, start, left - 1)
    # 右部
    quick_sort(alist, left + 1, end)


if __name__ == '__main__':
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print(li)
    quick_sort(li, 0, len(li) - 1)
    print(li)

• 归并排序：

def merge_sort(alist):
    """归并排序"""
    n = len(alist)
    if n == 1:
        return alist
    mid = n // 2
    # 将列表分成两段，分别再进行归并排序
    left_sorted_li = merge_sort(alist[:mid])
    right_sorted_li = merge_sort(alist[mid:])

    # 创建游标，进行比较
    left, right = 0, 0
    merge_sorted_li = []
    left_n = len(left_sorted_li)
    right_n = len(right_sorted_li)
    while left < left_n and right < right_n:
        if left_sorted_li[left] < right_sorted_li[right]:
            merge_sorted_li.append(left_sorted_li[left])
            left += 1
        else:
            merge_sorted_li.append(right_sorted_li[right])
            right += 1
    # 当有一个游标超出界限后，需要将剩下的内容添加到新列表内
    merge_sorted_li += left_sorted_li[left:]
    merge_sorted_li += right_sorted_li[right:]

    return merge_sorted_li


if __name__ == '__main__':
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print("merge_sort：归并排序：")
    print(li)
    print(merge_sort(li))