常用排序算法的Python实现

参考：http://python.jobbole.com/82270/
代码：

def insert_sort(list_1):    # 插入排序    list_length = len(list_1)    for i in range(1, list_length):        # 关键是每次都从要排序的元素的前一个元素开始比较        j = i - 1        the_element = list_1[i]        while j >= 0:            if list_1[j] > the_element:                list_1[j + 1] = list_1[j]                list_1[j] = the_element            j -= 1    return list_1def shell_sort(list_1):    # 希尔排序    list_length = len(list_1)    step = 2    group = list_length // step    while group > 0:        for i in range(group):            j = i + group            while j < list_length:                # 在每组中用插入排序                k = j - group                the_element = list_1[j]                while k > 0:                    if list_1[k] > the_element:                        list_1[k + group] = list_1[k]                        list_1[k] = the_element                    k -= group                j += group        group //= step    return list_1def bubble_sort(list_1):    # 冒泡排序    list_length = len(list_1)    for i in range(list_length):        the_element = list_1[i]        for j in range(i + 1, list_length):            if the_element > list_1[j]:                list_1[i] = list_1[j]                list_1[j] = the_element    return list_1def quick_sort(list_1, start, end):    # 快速排序    if start < end:        i, j = start, end        base = list_1[i]        while i < j:            # 关键是移动首部和尾部的两个指针            # 每次这个外部while循环最多只交换一次前面部分和后面部分的值            while i < j and list_1[j] >= base:                j -= 1            list_1[i] = list_1[j]            while i < j and list_1[i] <= base:                i += 1            list_1[j] = list_1[i]        # 等到上面的while结束了也就是一趟快排结束了，需要将base保存        list_1[i] = base        quick_sort(list_1, start, i - 1)        quick_sort(list_1, j + 1, end)    return list_1def select_sort(list_1):    # 选择排序    list_length = len(list_1)    for i in range(list_length):        min_index = i        for j in range(i + 1, list_length):            # 找寻后面部分最小的元素与之交换            if list_1[j] < list_1[min_index]:                min_index = j        list_1[i], list_1[min_index] = list_1[min_index], list_1[i]    return list_1def adjust_heap(list_1, position, length):    # 其实就是让position位置的元素下沉    lchild_index = 2 * position + 1    rchild_index = 2 * position + 2    max_index = position    if lchild_index < length and list_1[max_index] < list_1[lchild_index]:        max_index = lchild_index    if rchild_index < length and list_1[max_index] < list_1[rchild_index]:        max_index = rchild_index    if max_index != position:        list_1[position], list_1[max_index] = list_1[max_index], list_1[position]        adjust_heap(list_1, max_index, length)def build_heap(list_1, length):    # 创建堆，就是前一半的元素挨个下沉    for i in range(length // 2)[::-1]:        adjust_heap(list_1, i, length)def heap_sort(list_1):    # 堆排序    list_length = len(list_1)    build_heap(list_1, list_length)    for i in range(list_length)[::-1]:        # 把最大的元素（堆顶）换到最后        list_1[i], list_1[0] = list_1[0], list_1[i]        # 调整交换之后的除了最后一个元素的堆        adjust_heap(list_1, 0, i)    return list_1def merge(left_list, right_list):    i, j = 0, 0    result = []    while i < len(left_list) and j < len(right_list):        if left_list[i] <= right_list[j]:            result.append(left_list[i])            i += 1        else:            result.append(right_list[j])            j += 1    # 这两行是为了防止上面的while中有一遍的列表没有添加完    result += left_list[i:]    result += right_list[j:]    return resultdef merge_sort(list_1):    # 归并排序    list_length = len(list_1)    if list_length <= 1:        return list_1    num = list_length // 2    result_left = merge_sort(list_1[:num])    result_right = merge_sort(list_1[num:])    return merge(result_left, result_right)def bucket_sort(list_1):    # 桶排序    min_value, max_value = min(list_1), max(list_1)    bucket_list = [0] * (max_value - min_value + 1)    for i in range(len(list_1)):        bucket_list[list_1[i] - min_value] += 1    result = []    for j in range(len(bucket_list)):        if bucket_list[j] != 0:            result += bucket_list[j] * [j + min_value]    return resultimport mathdef radix_sort(list_1, radix=10):    # 基数排序    # 最大的数有多少位    k = int(math.ceil(math.log(max(list_1), radix)))    # 0-9建立10个桶    buckets = [[] for i in range(radix)]    for i in range(1, k + 1):        # 依次根据个位、十位、百位进行排序        for element in list_1:            buckets[element // radix**(i - 1) % (radix * i)].append(element)        del list_1[:]        for bucket in buckets:            list_1 += bucket            del bucket[:]    return list_1test_list = [52, 3, 1, 2, 6, 4, 22, 2, 12, 41]print('内置排序：', sorted(test_list))print('插入排序：', insert_sort(test_list))print('希尔排序：', shell_sort(test_list))print('冒泡排序：', bubble_sort(test_list))print('快速排序：', quick_sort(test_list, 0, len(test_list) - 1))print('选择排序：', select_sort(test_list))print('堆排序  ：', heap_sort(test_list))print('归并排序：', merge_sort(test_list))print('桶排序  ：', bucket_sort(test_list))print('基数排序：', radix_sort(test_list))

结果：

内置排序： [1, 2, 2, 3, 4, 6, 12, 22, 41, 52]插入排序： [1, 2, 2, 3, 4, 6, 12, 22, 41, 52]希尔排序： [1, 2, 2, 3, 4, 6, 12, 22, 41, 52]冒泡排序： [1, 2, 2, 3, 4, 6, 12, 22, 41, 52]快速排序： [1, 2, 2, 3, 4, 6, 12, 22, 41, 52]选择排序： [1, 2, 2, 3, 4, 6, 12, 22, 41, 52]堆排序  ： [1, 2, 2, 3, 4, 6, 12, 22, 41, 52]归并排序： [1, 2, 2, 3, 4, 6, 12, 22, 41, 52]桶排序  ： [1, 2, 2, 3, 4, 6, 12, 22, 41, 52]基数排序： [1, 2, 2, 3, 4, 6, 12, 22, 41, 52]