經典排序算法實現（Python）

十大經典排序算法（動圖演示）：這個鏈接裏動圖不錯，不過是JS實現

1. 交換排序 -- 冒泡排序

# BubbleSort
def main(data):
    high = len(data) - 1
    low = 0
    while low < high:
        if data[low] > data[low + 1]:
            data[low], data[low + 1] = data[low + 1], data[low]
        low += 1
        if low == high:
            high -= 1
            low = 0

2. 交換排序 -- 快排

def base_sort(data, low, high):
    half = data[low]
    while low < high:
        while data[high] >= half and low < high:
            high -= 1
        data[low] = data[high]
        while data[low] <= half and low < high:
            low += 1
        data[high] = data[low]
    data[low] = half
    return low


def main(data, low=None, high=None):
    if low is None:
        low = 0
        high = len(data) - 1
    if low > high:
        return
    # 先序
    half_index = base_sort(data, low, high)
    main(data, low, half_index - 1)
    main(data, half_index + 1, high)

3. 插入排序 -- 簡單插入排序

def main(data):
    end = 0
    start = 1
    while start < len(data):
        while data[end] > data[start] and end >= 0:
            end -= 1
        data.insert(end + 1, data.pop(start))
        start += 1
        end = start - 1

4. 插入排序 -- 希爾排序

def main(data):
    gap = len(data) // 2
    while gap >= 1:
        end = 0
        while end + gap < len(data):
            start = end + gap
            while start < len(data):
                while data[end] > data[start] and end >= 0:
                    end -= gap
                data.insert(end + 1, data.pop(start))
                end = start
                start += gap
            end += 1
        gap = gap // 2

5. 選擇排序 -- 簡單選擇排序

def main(data):
    low = 0
    high = len(data) - 1
    max_index = high
    while low < high:
        if data[low] > data[max_index]:
            max_index = low
        low += 1
        if low == high:
            if max_index != high:
                data[max_index], data[high] = data[high], data[max_index]
            high -= 1
            max_index = high
            low = 0

6. 選擇排序 -- 堆排序

def modify(data, i, max_index):
    left = i * 2
    right = left + 1
    down = 0
    if right <= max_index:
        if data[i - 1] >= max(data[left - 1], data[right - 1]):
            return
        if data[left - 1] > data[right - 1]:
            data[i - 1], data[left - 1] = data[left - 1], data[i - 1]
            down = left
        else:
            data[i - 1], data[right - 1] = data[right - 1], data[i - 1]
            down = right
    elif left <= max_index:
        if data[i - 1] < data[left - 1]:
            data[i - 1], data[left - 1] = data[left - 1], data[i - 1]
            down = left
    if down != 0:
        modify(data, down, max_index)


def mk_heap(data, max_index):
    current_i = max_index // 2
    while current_i > 0:
        modify(data, current_i, max_index)
        current_i -= 1


def main(data):
    max_index = len(data)
    mk_heap(data, max_index)
    while max_index > 0:
        data[0], data[max_index - 1] = data[max_index - 1], data[0]
        max_index -= 1
        modify(data, 1, max_index)

7. 歸併排序 -- 二路歸併排序

def base_sort(data, l1, r1, l2, r2):
    tmp_list = []
    tmp_l1 = l1
    while l1 <= r1 and l2 <= r2:
        if data[l1] < data[l2]:
            tmp_list.append(data[l1])
            l1 += 1
        else:
            tmp_list.append(data[l2])
            l2 += 1
    if l1 <= r1:
        tmp_list += data[l1:r1 + 1]
    if l2 <= r2:
        tmp_list += data[l2:r2 + 1]
    data[tmp_l1:r2 + 1] = tmp_list


def main(data, l1=None, r2=None):
    if l1 is None:
        l1 = 0
        r2 = len(data) - 1
    if r2 - l1 < 1:
        return
    half = (r2 - l1) // 2
    r1 = l1 + half
    l2 = r1 + 1
    # 後序
    main(data, l1, r1)
    main(data, l2, r2)
    base_sort(data, l1, r1, l2, r2)

8. 非比較排序 -- 計數排序

def main(data):
    min_value, max_value = min(data), max(data)
    tmp_list = [0] * (max_value - min_value + 1)
    for i in data:
        tmp_list[i - min_value] += 1
    index = 0
    for i, count in enumerate(tmp_list):
        while count > 0:
            data[index] = i + min_value
            count -= 1
            index += 1

9. 非比較排序 -- 基數排序

def get_d(i, n):
    s = str(i)
    if n > len(s):
        return 0
    return int(s[len(s) - n])


def main(data, max_n=4):
    buckets = [[], [], [], [], [], [], [], [], [], []]
    for n in range(1, max_n + 1):
        for i in data:
            buckets[get_d(i, n)].append(i)
        index = 0
        for bucket in buckets:
            while len(bucket) != 0:
                data[index] = bucket.pop(0)
                index += 1