排序算法（三人组加上快排）

冒泡排序

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。

这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

def bubble_sort(li):
    for i in range(len(li)-1):
        for j in range(len(li)-i-1):
            if li[j]>li[j+1]:
                li[j],li[j+1]=li[j+1],li[j]
    return li
print(bubble_sort([112,1245325,2342,323]))

选择排序

def select_sort(li):
    for i in range(len(li)-1):
        min_loc=i
        for j in range(i+1,len(li)):
            if li[j]<li[min_loc]:
                min_loc=j
        if li[min_loc]!=i:
            li[i],li[min_loc]=li[min_loc],li[i]
    return li
print(select_sort([11,23124,235,345,346,46]))

插入排序

def insert_sort(li):
    for i in range(1,len(li)):
        tmp=li[i]
        j=i-1
        while j>=0 and tmp<li[j]:
            li[j+1]=li[j]
            j=j-1
        li[j+1]=tmp
    return li
print(insert_sort([11231,423,5,436]))

前面三种算法的时间复杂度都是O(n2),空间复杂度都是O(1)

快速排序

def quick_sort(data,left,right):
    if left < right:
        mid=partition(data,left,right)
        quick_sort(data,left,mid-1)
        quick_sort(data,mid+1,right)
    return data
def partition(data,left,right):
    tmp=data[left]
    while left < right:
        while left < right and data[right]>=tmp:
            right-=1
        data[left]=data[right]
        while left < right and data[left] <=tmp:
            left+=1
        data[right]=data[left]
    data[left]=tmp
    return left
data=[11,243,25,534,6]
print(quick_sort(data,0,len(data)-1))

时间复杂度：O(nlog₂n)

空间复杂度：O(nlog₂n)