常见5种排序算法：冒泡排序、选择排序、插入排序、快速排序、归并排序，python实现

一.冒泡排序

算法描述：相邻元素两两进行比较，满足条件则交换位置，每一次遍历都会将剩余元素中最大的元素归位。

# 最坏时间复杂度：n2
# 最优时间复杂度：n，代码需优化，如果遍历一遍后发现没有要交换的元素，则结束排序
# j为遍历的次数，i为每次遍历比较的次数
# 稳定
# 参考：https://www.cnblogs.com/fwl8888/p/9315730.html


# method_1
def hello(L):
    n = len(L)
    print(L, end='\n\n')
    for i in range(n, 1, -1):  # 遍历5次,i:6-2
        for j in range(0, i - 1):  # 第一次遍历比较5次,j:0-4
            if L[j] > L[j + 1]:
                L[j], L[j + 1] = L[j + 1], L[j]
        print(L)
    return L


# method_2
def bubble_sort(L):
    n = len(L)
    print(L, end='\n\n')
    for j in range(n - 1, 0, -1):
        for i in range(j):
            if L[i] > L[i + 1]:
                L[i], L[i + 1] = L[i + 1], L[i]
        print(L)
    return L


# 优化算法
def super_bubble_sort(L):
    n = len(L)
    print(L, end='\n\n')
    for j in range(n - 1, 0, -1):
        flag = 0
        for i in range(j):
            if L[i] > L[i + 1]:
                L[i], L[i + 1] = L[i + 1], L[i]
                flag = 1
        if flag == 0:
            return L
        print(L)
    return L


L = [4, 9, 67, 11, 33, 18, 19, 13, 2]
hello(L)
#bubble_sort(L)
#super_bubble_sort(L)

'''
result:
[4, 9, 67, 11, 33, 18, 19, 13, 2]

[4, 9, 11, 33, 18, 19, 13, 2, 67]
[4, 9, 11, 18, 19, 13, 2, 33, 67]
[4, 9, 11, 18, 13, 2, 19, 33, 67]
[4, 9, 11, 13, 2, 18, 19, 33, 67]
[4, 9, 11, 2, 13, 18, 19, 33, 67]
[4, 9, 2, 11, 13, 18, 19, 33, 67]
[4, 2, 9, 11, 13, 18, 19, 33, 67]
[2, 4, 9, 11, 13, 18, 19, 33, 67]
'''

二.选择排序

算法描述：每次遍历选出一个最大的元素，并将其与数组（不断变化）最后一个元素进行交换。

# 最优/坏时间复杂度：n2
# 不稳定


def selection_sort(L):
    n = len(L)
    print(L, end='\n\n')
    for i in range(n, 1, -1):  # 5次 i:6-2
        max_index = 0
        for j in range(0, i):  # j:0-5
            if L[j] > L[max_index]:
                max_index = j
        L[max_index], L[i - 1] = L[i - 1], L[max_index]
        print(L)
    return L


L = [4, 9, 67, 11, 33, 18, 19, 13, 2]
selection_sort(L)

'''
result:
[4, 9, 67, 11, 33, 18, 19, 13, 2]

[4, 9, 2, 11, 33, 18, 19, 13, 67]
[4, 9, 2, 11, 13, 18, 19, 33, 67]
[4, 9, 2, 11, 13, 18, 19, 33, 67]
[4, 9, 2, 11, 13, 18, 19, 33, 67]
[4, 9, 2, 11, 13, 18, 19, 33, 67]
[4, 9, 2, 11, 13, 18, 19, 33, 67]
[4, 2, 9, 11, 13, 18, 19, 33, 67]
[2, 4, 9, 11, 13, 18, 19, 33, 67]
'''

三.插入排序

算法描述：将数组的第一个元素看做是一个排好序的数组，每次从后边取一个元素插入至有序数组中，n-1次插入后完成排序。
注意：这里的插入应用了冒泡排序的思想（多次交换），并不是直接插入（一次交换）

# 最优：n
# 最坏：n2
# 稳定


def insertion_sort(L):
    n = len(L)
    print(L, end='\n\n')
    for i in range(1, n):
        for j in range(i, 0, -1):
            if L[j] < L[j-1]:
                L[j], L[j-1] = L[j-1], L[j]
        print(L)
    return L


L = [4, 9, 67, 11, 33, 18, 19, 13, 2]
insertion_sort(L)

'''
result:
[4, 9, 67, 11, 33, 18, 19, 13, 2]

[4, 9, 67, 11, 33, 18, 19, 13, 2]
[4, 9, 67, 11, 33, 18, 19, 13, 2]
[4, 9, 11, 67, 33, 18, 19, 13, 2]
[4, 9, 11, 33, 67, 18, 19, 13, 2]
[4, 9, 11, 18, 33, 67, 19, 13, 2]
[4, 9, 11, 18, 19, 33, 67, 13, 2]
[4, 9, 11, 13, 18, 19, 33, 67, 2]
[2, 4, 9, 11, 13, 18, 19, 33, 67]
'''

四.快速排序（较难理解）

算法描述：选取数组的第一个元素作为基准，将小于基准的元素放左边，大于基准的元素放右边，然后通过递归思想完成排序。

# 最优：O(nlogn)
# 最坏：O(n2)
# 不稳定
# 参考：https://blog.csdn.net/vayne_xiao/article/details/53508973


def quick_sort(L, left, right):
    # 递归退出条件
    if left > right:
        return

    i = left  # 数组左索引
    j = right # 数组右索引
    temp = L[left]  # 选取列表的第一个元素为基准元素

    # i与j碰头时（i=j），退出循环，即L[i]左边的元素都比L[i]小，右边的元素都比L[i]大
    while i != j:
        # 从右往左搜索比L[i]小的元素，则终止循环，此时j指向L[j]，L[j]<temp
        while L[j] >= temp and i < j:
            j -= 1
        # 从左往右搜索比L[i]大的元素，则终止循环，此时i指向L[i]，L[i]>temp
        while L[i] <= temp and i < j:
            i += 1
        # 若i<j，即i,j指向的不是同一个元素，则交换之
        if i < j:
            L[i], L[j] = L[j], L[i]

    # i与j碰头，将L[i]/L[left]互换, 此时基准元素L[left]归位（归中）
    L[left], L[i] = L[i], L[left]

    # 对L[i]左边和右边的子序列进行快速排序
    quick_sort(L, left, i - 1)  # 对应递归退出条件
    quick_sort(L, i + 1, right)  # 对应递归退出条件


L = [4, 9, 67, 11, 33, 18, 19, 13, 2, 27]
quick_sort(L, 0, len(L)-1)
print(L)

'''
result:
[2, 4, 9, 11, 13, 18, 19, 27, 33, 67]
'''

五.归并排序

算法描述：递归思想

# 最优、坏时间复杂度：O(nlogn)
# 稳定
# 递归思想


def merge_sort(L):
    if len(L) == 1:
        return L
    num = len(L)//2
    # 分解数组直到每个元素都是一个数组，即有序
    left = merge_sort(L[:num])
    right = merge_sort(L[num:])
    # 将两个有序数组合并为一个数组
    return merge(left, right)


def merge(left, right):
    i, j = 0, 0
    result = []
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result += left[i:]
    result += right[j:]
    return result


L = [4, 9, 67, 11, 33, 18, 19, 13, 2]
print(merge_sort(L))

'''
result:
[2, 4, 9, 11, 13, 18, 19, 33, 67]
'''