常用排序算法的Python实现

最新推荐文章于 2023-02-02 19:57:35 发布

Chester-zZz

最新推荐文章于 2023-02-02 19:57:35 发布

阅读量578

点赞数

分类专栏： Python 文章标签： python 排序算法

本文链接：https://blog.csdn.net/u014433413/article/details/78493916

版权

Python 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

参考：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_1


def 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_1


def 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_1


def 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_1


def 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_1


def 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_1


def 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 result


def 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 result


import math


def 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_1


test_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]