常用排序算法（Python）

冒泡排序：

核心思想：遍歷長度爲n的數組，每輪序號爲i，第i輪將最值移動到數組倒數n-i的位置，第i輪中，內層循環到第n-i個值爲止

也就是說，每輪循環中將這一輪中最值移動到數組尾部，下一輪循環時與已經移動到尾部的值無關

def bubble_sort(l):
    assert isinstance(l, list)
    size = len(l)
    if size <= 1:
        return l

    for i in range(size):
        for j in range(size - i - 1):
            if l[j] < l[j + 1]:
                l[j], l[j + 1] = l[j + 1], l[j]
    return l


if __name__ == '__main__':
    arr = [5, 2, 6, 3]
    print(bubble_sort(arr))

插入排序：

核心思想：按順序遍歷數組，每次將取出的值和新數組中已有值進行比較，有以下幾種情況：
1：比ret中的最大值大，插入最前面；2：介於ret中某兩個數中間，插入這兩個數中間；3：1,2兩種情況之外，追加到數組最後

def insert_sort(l):
    assert isinstance(l, list)
    size = len(l)
    if size <= 1:
        return l
    ret = []

    for i in range(size):
        for j in range(len(ret)):
            if l[i] >= ret[j] and (j == 0 or l[i] < ret[j - 1]):
                ret.insert(j, l[i])
                break
        else:
            ret.append(l[i])

    return ret


if __name__ == '__main__':
    arr = [5, 2, 6, 3, 1, 2]
    print(insert_sort(arr))

選擇排序：

核心思想：

for i in len（list），每次找到從位置i開始到末尾中最值的index，將i與index對應的值進行交換

def select_sort(l):
    assert isinstance(l, list)
    size = len(l)
    if size <= 1:
        return l

    def _max(start):
        max_index = start
        for i in range(start, size):
            if l[max_index] < l[i]:
                max_index = i
        return max_index

    for i in range(size):
        index = _max(i)
        if i != index:
            l[index], l[i] = l[i], l[index]

    return l


if __name__ == '__main__':
    arr = [5, 2, 6, 3, 8, 2]
    print(select_sort(arr))

合併排序：

核心思想：每次把數組從中間截斷爲兩個數組，對這兩個數組分別進行遞歸調用合併排序，然後將排序後的兩個數組合併爲最終結果

def merge_sort(l):
    assert isinstance(l, list)
    size = len(l)
    if size <= 1:
        return l
    if size == 2:
        if l[0] < l[1]:
            l[0], l[1] = l[1], l[0]
        return l
    else:
        ret = []
        mid_index = size // 2
        l_a = merge_sort(l[0:mid_index])
        l_b = merge_sort(l[mid_index:size])
        i = 0
        j = 0
        while len(ret) < size:
            if i >= len(l_a):
                ret.extend(l_b[j:])
                break
            if j >= len(l_b):
                ret.extend(l_a[i:])
                break
            if l_a[i] > l_b[j]:
                ret.append(l_a[i])
                i += 1
            else:
                ret.append(l_b[j])
                j += 1
        return ret


if __name__ == '__main__':
    arr = [5, 2, 6, 3, 1, 2]
    print(merge_sort(arr))

快速排序：

核心思想：任取一值，將其分爲大於等於該值的數組和小於該值的數組，對分離出的兩個數組再進行排序，得到兩個排序好的數組，然後將所得的兩個數組，和中間值拼接成一個數組

def quick_sort(l):
    assert isinstance(l, list)
    if len(l) <= 1:
        return l
    l_gt = [x for x in l[1:] if x >= l[0]]
    l_lt = [x for x in l[1:] if x < l[0]]
    return quick_sort(l_gt) + [l[0]] + quick_sort(l_lt)


if __name__ == '__main__':
    arr = [5, 2, 6, 3, 8, 2]
    print(quick_sort(arr))

此外，還有堆排序，二叉樹排序，木桶排序等，留待以後補充