常见排序算法

常见排序算法有很多种，这里仅列举冒泡排序、插入排序、选择排序、归并排序。

 冒泡：现有一个列表有n项，每一轮比较的次数：当前未比较项数-1，且每一轮产生一个最大值，

时间复杂度：最好O（n），一般及最坏O（n方）

# for实现
lst = [7,9,3,11,45,23,12,87,234,12,5,93]
n = len(lst)

for i in range(n-1):
    flag = True
    for j in range(n-1-i):
        if lst[j] > lst[j+1]:
            lst[j],lst[j+1] = lst[j+1],lst[j]
            flag = False
    if flag :
        break

print('lst: ',lst)

# while实现
lst1 = [7,9,3,11,45,23,12,87,234,12,5,93]
i = 1
n = len(lst1)

while i < n:
    j = 0
    flag = True
    while j < n-i:
        if lst1[j] > lst1[j+1]:
            lst1[j],lst1[j+1] = lst1[j+1],lst1[j]
            flag = False
        j += 1
    if flag:
        break
    i += 1

print('lst1:',lst1)

运行结果：

lst:  [3, 5, 7, 9, 11, 12, 12, 23, 45, 87, 93, 234]
lst1: [3, 5, 7, 9, 11, 12, 12, 23, 45, 87, 93, 234]

插入排序：每次取一个新数字与已取过数字比较，每轮后取过的数字都排好顺序，时间复杂度O（n方）

lst = [3,88,76,23,999,22,888,56,39,72]

for i in range(len(lst)):
    key = lst[i]
    j = i-1
    while j >= 0 and lst[j]> key:
        lst[j],lst[j+1] = lst[j+1],lst[j]
        j -= 1

print('lst: ',lst)

运行结果：

lst:  [3, 22, 23, 39, 56, 72, 76, 88, 888, 999]

选择排序：每一轮排出一个最小值，时间复杂度also is O（n方），但是因为交换次数少，速度比冒泡快

lst = [7,9,3,11,45,23,12,87,234,11,5,93]
n = len(lst)

for i in range(n-1):
    small = i
    for j in range(i+1,n):
        if lst[j] < lst[small]:
            small = j
    if small != i:
        lst[i],lst[small] = lst[small],lst[i]

print('lst: ',lst)

运行结果：

lst:  [3, 5, 7, 9, 11, 11, 12, 23, 45, 87, 93, 234]

归并排序：原则是用递归先将序列分成最小两单元，然后排序再合并。。。最后将排好序的两个子序列再排序合并成一个有序序列

def merge(a, b):
    c = []
    h = j = 0
    while j < len(a) and h < len(b):
        if a[j] < b[h]:
            c.append(a[j])
            j += 1
        else:
            c.append(b[h])
            h += 1

    if j == len(a):
        for i in b[h:]:
            c.append(i)
    else:
        for i in a[j:]:
            c.append(i)

    return c

def merge_sort(lists):
    if len(lists) <= 1:
        return lists
    mid = len(lists)//2
    left = merge_sort(lists[:mid])
    right = merge_sort(lists[mid:])
    return merge(left, right)

if __name__ == '__main__':
    lst = [20,5,12,9,18,25,20,3]
    print(merge_sort(lst))

运行结果：

[3, 5, 9, 12, 18, 20, 20, 25]

 另一种写法：O（nlogn）

def merge(val):
    if len(val) > 1:　　　　
        mid = len(val)//2
        left = val[:mid]
        right = val[mid:]

        merge(left)
        merge(right)

        i = 0
        j = 0
        k = 0
        while i < len(left) and j < len(right):　　#left 和 right必有一边最终全部排完序，如left排完序后，最终情况是val是有序序列，left中也是有序序列
            if left[i] < right[j]:　　　　　　　　　　#接下来把left中未排序的元素全部加入val中即可
                val[k] = left[i]
                i += 1
            else:
                val[k] = right[j]
                j += 1
            k += 1
        while i < len(left):　　　　#此后两个while表示，谁在上一步没有排完序，就单独将其剩余元素加入val即可
            val[k] = left[i]
            i += 1
            k += 1
        while j < len(right):
            val[k] = right[j]
            j += 1
            k += 1
    return val