排序算法-python

'''
快速排序
递归，选择基准比较
'''
def quick_sort(array):
    if not array:
        return []
    base = array[0]
    arr_len = len(array)
    min_low, min_upper = 1, arr_len
    for i in range(1, arr_len):
        if array[i] < base:
            min_low = min(i, min_low)
            if min_upper != arr_len:
                array[i], array[min_upper] = array[min_upper], array[i]
                min_upper = min_upper+1
        else:
            min_upper = min(i, min_upper)
    array[0], array[min_upper-1] =  array[min_upper-1], array[0]
    return quick_sort(array[:min_upper-1])+[base]+quick_sort(array[min_upper:])


'''
选择排序
'''
def insert_sort(array):
    if not array:
        return []
    arr_len = len(array)
    for i in range(1, arr_len):
        t ,tp = 0, array[0]
        flag = True
        for j in range(0, i):
            if array[i] < array[j]:
                t = j
                tp = array[i]
                flag = False
                break                
        if not flag:
            for j in range(i, t, -1):
                if j >= 1:
                    array[j]=array[j-1]
            array[t] = tp
    
    return array

'''
希尔排序：增量递减插入排序
'''
def shell_sort(array):
    arr_len = len(array)
    gap = int(arr_len/2)

    while gap > 0:
        for i in range(gap, arr_len, gap):
            ret = True
            t =0
            temp = array[i]
            for j in range(0, i, gap):
                if array[j] > temp:
                    ret = False
                    t = j
                    break
            if not ret:
                for k in range(i, t, -gap):
                    if k>=gap:
                        array[k] = array[k-gap]
                array[t] = temp
        gap = int(gap/2)
    
    return array
'''
归并排序
递归法
'''
def merge_sort(array):

    arr_len = len(array)
    if arr_len == 1:
        return array
    idx = int(arr_len/2)
    if idx <= 0:
        return []
    return  merge_sorted(merge_sort(array[:idx]) , merge_sort(array[idx:]))

def merge_sorted(arr1, arr2):
    new_arr = []
    if not arr1:
        return arr2
    if not arr2:
        return arr1
    i, j = 0, 0
    while i < len(arr1) or j < len(arr2):
        if (i< len(arr1) and j< len(arr2) and arr1[i] < arr2[j]) or j >= len(arr2):
            new_arr.append(arr1[i])
            i += 1
        else:
            new_arr.append(arr2[j])
            j +=1
        # if i >= len(arr1) and j >= len(arr2):
        #     break
    return new_arr

'''
冒泡排序
'''
def buddle_sort(array):
    if not array:
        return []
    arr_len = len(array)
    for k in range(arr_len):
        for i in range(1, arr_len-k):
            if array[i] < array[i-1]:
                array[i], array[i-1] = array[i-1], array[i]
    return array

'''
选择排序
'''
def select_sort(array):
    if not array:
        return []
    arr_len = len(array)
    for i in range(arr_len):
        maxv = array[0]
        max_idx = 0
        for j in range(arr_len-i):
            if maxv < array[j]:
                maxv = array[j]
                max_idx = j 
        array[max_idx], array[arr_len-1-i] = array[arr_len-1-i], array[max_idx]
    return array

'''
计数排序
'''
def count_sort(array):
    if not array:
        return []
    arr_len = len(array)
    minv, maxv = min(array), max(array)
    count_arr = []
    for i in range(minv, maxv+1):
        count_arr.append(0)
    for i in range(arr_len):
        count_arr[array[i]-minv] += 1
    new_arr = []
    for i in range(len(count_arr)):
        n = count_arr[i]
        while  n > 0:
            new_arr.append(minv+i)
            n = n-1
    return new_arr


'''
桶排序
'''
def bucket_sort(array):
    if not array:
        return []
    bucket_num = 10
    minv, maxv = min(array), max(array)
    bucket_arr = [[] for i in range(bucket_num)]

    for i in range(len(array)):
        for j in range(bucket_num, 0, -1):
            if array[i] >= (j-1)*(maxv-minv)/bucket_num+minv:
                bucket_arr[j-1].append(array[i])
                break
    new_arr = []
    for i in range(bucket_num):
        new_arr += select_sort(bucket_arr[i])
    return new_arr



def test_case_sort():
    import random
    array = [random.randint(0, 2000) for i in range(200)]
    sorted_array = array.copy()
    sorted_array.sort()
    dirsered_ret = sorted_array
    # print("array:", array)
    # print("sorted:", dirsered_ret)

    assert dirsered_ret == quick_sort(array.copy()), "array:{}, sorted_ret:{}".format(array, quick_sort(array.copy()))
    assert dirsered_ret == insert_sort(array.copy()), "array:{}, sorted_ret:{}".format(array, insert_sort(array.copy()))
    assert dirsered_ret == shell_sort(array.copy()), "array:{}, sorted_ret:{}".format(array, shell_sort(array.copy()))
    assert dirsered_ret == merge_sort(array.copy()), "array:{}, sorted_ret:{}".format(array, merge_sort(array.copy()))
    assert dirsered_ret == buddle_sort(array.copy()), "array:{}, sorted_ret:{}".format(array, buddle_sort(array.copy()))
    assert dirsered_ret == select_sort(array.copy()), "array:{}, sorted_ret:{}".format(array, select_sort(array.copy()))
    assert dirsered_ret == count_sort(array.copy()), "array:{}, sorted_ret:{}".format(array, count_sort(array.copy()))
    assert dirsered_ret == bucket_sort(array.copy()), "array:{}, sorted_ret:{}".format(array, bucket_sort(array.copy()))

if __name__ == "__main__":
    test_case_sort()