Python实现常见的排序算法

1.冒泡排序

# [6,3,9,4,2]
def bubble_sort(li):
    n = len(li)
    # 确定冒泡排序的趟数 n - 1
    for j in range(n - 1): # 0 1 2 3

        count = 0
        # 冒泡排序一趟，把最大的一个数排到最右边
        for i in range(n - 1 - j): # 0 3 每一趟冒泡 比较的次数越来越少
            if li[i] > li[i + 1]:
                # 交换
                li[i], li[i + 1] = li[i + 1], li[i]
                count += 1
        # for循环结束时，如果没有交换过，证明已经有序，直接返回
        if count == 0:
            break

if __name__ == ‘__main__‘:
    l = [1,1,2,4,5,6]
    # 3, 6, 4, 2, 9
    # i = 3
    # 3,6,4,2,9
    # 3,4,2,6,9
    bubble_sort(l)
    print(l)
    # 最坏时间复杂度：O(n^2)
    # 最优时间复杂度：O(n)
    # 稳定性：稳定

2.选择排序

# [6,3,9,4,2]
def select_sort(li):
    n = len(li)
    # 总共选择的次数，每次选择的最小数 放的位置 0 ~ n-1
    for j in range(n - 1):

        # 选择一次，找出最小的一个数，放到0位置
        temp = j  # 从这个位置开始比较，比较出最小的数放到这个位置
        for i in range(j + 1, n):
            if li[i] < li[temp]:
                temp = i
        # for循环结束时，temp指向最小的数
        # 交换temp和0位置
        li[temp], li[j] = li[j], li[temp]

if __name__ == ‘__main__‘:

    l = [1,2,3,4,5]
    # 2,3,9,4,6
    select_sort(l)
    print(l)
    # 最坏时间复杂度：O(n^2)
    # 最优时间复杂度：O(n^2)
    # 稳定性：不稳定

3.插入排序

# [6,3,9,4,2]
def insert_sort(li):
    n = len(li)
    # 不停的指向插入排序，从1~n-1 位置的数据，依次跟前面有序的序列组成有序
    for j in range(1, n):

        # 把0位置的数认为有序，把下一个位置跟前面组成有序
        for i in range(j, 0, -1):
            if li[i] < li[i - 1]:
                li[i], li[i - 1] = li[i - 1], li[i]
            else:
                break

if __name__ == ‘__main__‘:
    l = [1,2,3,4,5]
    insert_sort(l)
    print(l)

    # 最坏时间复杂度：O(n^2)
    # 最坏时间复杂度：O(n)
    # 稳定性：稳定

4.希尔排序

# [6,1,4,2,5,3]
def shell_sort(li):
    n = len(li)
    # 设置步长，根据步长进行排序
    gap = n//2

    # 不停的改变步长，最后一个步长必须是1
    while gap >= 1:

        for i in range(gap, n):
            while (i - gap) >= 0:
                if li[i] < li[i - gap]:
                    li[i], li[i - gap] = li[i - gap], li[i]
                i -= gap

        gap //= 2
if __name__ == ‘__main__‘:

    l = [6,1,4,2,5,3]
    shell_sort(l)
    # 最坏时间复杂度:O(n^2)
    # 最坏时间复杂度: 跟步长相关
    # 稳定性：不稳定

5.快排

# [6,9,4,8,5,7]

def quick_sort(li, start, end):
    if start>=end:
        return
    # 左边角标
    left = start
    # 右边角标
    right = end
    # 把0位置的数作为中间值
    mid = li[left]

    while left < right:

        # 右边的角标往左移动，找的一个小于中间值的数，把数放到左边角标位置
        while left < right and li[right] >= mid:
            right -= 1
        # 当white循环结束时，right指向的值小于mid
        li[left] = li[right]

        # 左边的角标往右移动，找的一个大于中间值的数，把数放到右边边角标位置
        while left < right and li[left] <= mid:
            left += 1
        li[right] = li[left]
    # while结束，left=right，把中间值赋值到这个位置
    li[left] = mid

    # 排序左边的数据
    quick_sort(li, start, left-1)
    # 排序右边的数据
    quick_sort(li, left+1, end)

if __name__ == ‘__main__‘:
    l = [6,8,4,4]
    quick_sort(l,0,len(l)-1)
    print(l)
    # 最坏时间复杂度 ： O(n^2)
    # 最优时间复杂度 ： O(nlogn)
    # 稳定性：不稳定

6.归并排序

# [7,6,8,  9,10,2,1]

def merge_sort(li):
    if len(li) == 1:
        # print(li)
        return li
        # 获取中间位置
    mid = len(li) // 2

    # 拆分左右各一半
    left = li[:mid]
    right = li[mid:]

    # print(left)
    # print(right)

    # 递归拆分
    left_res = merge_sort(left)
    right_res = merge_sort(right)
    # result = left_res + right_res
    # print(result)
    # 合并排序
    result = merge(left_res,right_res)
    return result

def merge(left, right):
    # 把下层方法返回的数据进行排序
    # [6] [8]
    # [5,7,9] [6,8]
    # 5 6 7
    res = []
    left_index = 0
    right_index = 0

    while left_index < len(left) and right_index < len(right):

        if left[left_index] <= right[right_index]:
            res.append(left[left_index])
            left_index += 1
        else:
            res.append(right[right_index])
            right_index += 1
    # while结束后，把剩下的数据全部添加
    res += right[right_index:]
    res += left[left_index:]
    return res

if __name__ == ‘__main__‘:
    l = [7, 8, 6, 9, 10, 2, 1]
    print(merge_sort(l))

    # 最坏时间复杂度：O(nlogn)
    # 最优时间复杂度：O(nlogn)
    # 稳定性：稳定