冒泡排序， 选择排序，插入排序, 快速排序

 冒泡排序-时间复杂度O(n²)：

def maopao_sort(li):
    for i in range(len(li)-1):
        for j in range(len(li)-1-i):  # 因为每次排序完成后，最后一位就已经排序完成。
            if li[j] > li[j+1]:
                li[j], li[j+1] = li[j+1], li[j]  # 重点就是交换
    return li

 

选择排序-时间复杂度O(n²)：

def selected_sort(li):
    for i in range(len(li)):
        min_location = i
        for j in range(i+1, len(li)):
            if li[j] < li[min_location]:
                min_location = j
        li[min_location], li[i] = li[i], li[min_location]
    return li

 

插入排序-时间复杂度O(n²)：

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 -= 1
        li[j+1] = tmp
    return li

 

以上三种排序时间复杂度都是O(n²), 空间复杂度都是O(1)

 

快速排序-时间复杂度为O(n*logn)：

def partition(data, left=0, right=None):
    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


def quick_sort(data, left=0, right=None):
    if left < right:
        mid = partition(data, left, right)
        partition(data, left, mid-1)
        partition(data, mid+1, right)