python (冒泡、选择、插入、快速）排序算法详解 ！！！

1、冒泡排序

思路：每相邻的两个数进行比较，如果前边的比后边的数大，则交换这两个数，重复操作，这样的话每一趟会确定一个最大值，用老师的话说是让轻的飘起来，重的落下去.......所以，这个算法的关键点就是【趟】

如下代码所示，冒泡排序的时间复杂度为O（n2)

def bubble_sort(L):
    #确定排序的趟数
    for i in range(len(L)-1):
        #确定比较的次数
        for j in range(len(L)-i -1):
            if L[j] > L[j+1]:
                L[j],L[j+1] = L[j+1],L[j]
    return L

L = [7,5, 4, 6, 2, 8, 3, 1]
print(bubble_sort(L))

那么假如该排序列表为【1， 2， 3， 4， 5， 6， 8， 7】，则第一趟后交换8，7就已经是有序的了，后面的6趟就没有进行的必要了，所以设定一个exchange，用来标记该趟是否进行过交换，如果没有，则说明该列表已经是有序的了～

优化后代码：

def bubble_sort(L):
    for i in range(len(L)-1):
        exchange = False
        for j in range(len(L)-i -1):
            if L[j] > L[j+1]:
                L[j],L[j+1] = L[j+1],L[j]
                exchange = True
        if not exchange:
            return
    return L

L = [7,5, 4, 6, 2, 8, 3, 1]
print(bubble_sort(L))

2、选择排序

思路：第一趟遍历选择一个最小的数（或最大），放到第一个位置，下一趟遍历继续从列表中找最小的值放到已排序序列的末尾，说白了就是每趟找一个最小的值（或者最大的）～这个算法的关键在于最小数的【位置】

选择排序时间复杂度为O（n2)

def select_sort(L):
    for i in range(len(L)-1):
        min_loc = i
        for j in range(i+1, len(L)):
            if L[j] < L[min_loc]:
                min_loc = j
        if min_loc != i:
            L[i],L[min_loc] = L[min_loc], L[i]
    return L

L = [7,5, 4, 6, 2, 8, 3, 1]
print(select_sort(L))

3、插入排序

思路：将列表分为有序区和无序区，开始的时候有序区只有一个元素，每次从无序区取一个元素插入到有序区内，直到无序区内的元素被取完～这个算法的关键是【有序区已有】的元素和【即将要插入】到有序区的元素

插入排序的时间复杂度为O（n2)

def insert_sort(L):
    for i in range(1, len(L)):
        tmp = L[i]
        j = i - 1
        while j >= 0 and tmp < L[j]:
            L[j+1] = L[j]
            j = j - 1
        L[j+1] = tmp
    return L

L = [7,5, 4, 6, 2, 8, 3, 1]
print(insert_sort(L))

4、快速排序

思路：从列表中取一个元素，假如取第一个元素，将这个元素排好后前面的元素都比这个元素小，后面的都比这个元素大，即这个元素所在的位置即是完全排序后该元素的位置，后面递归处理即可～这个算法的关键即【递归】

快速排序的时间复杂度为O（nlogn)

def _sort(L, left, right):
    if left > right:
        return 
    low = left
    high = right
    tmp = L[low]
    while low < high:
        while low < high and L[high] >= tmp:
            high = high - 1
        L[low] = L[high]
        while low < high and L[low] < tmp:
            low = low + 1
        L[high] = L[low]
    L[low] = tmp
    _sort(L, left, low - 1)
    _sort(L, low + 1, right)
    return L

L = [7,5, 4, 6, 2, 8, 3, 1]
print(_sort(L,0,len(L)-1))