排序算法——冒泡、插入、选择、快速【Python】代码实现

最新推荐文章于 2024-01-10 00:04:27 发布

小林打怪中

最新推荐文章于 2024-01-10 00:04:27 发布

阅读量215

点赞数 9

分类专栏： Python 文章标签：算法数据结构排序算法

本文链接：https://blog.csdn.net/linxinyide/article/details/134909750

版权

Python 专栏收录该内容

13 篇文章 1 订阅

订阅专栏

一、概述

就是按照顺序（升序、降序）把一串数据给排列起来

二、分类

1、稳定性算法

特点：相同关键字的记录排序后，相对位置保持不变

例如：

1. 冒泡排序

核心思想：相邻元素两两比较，大的后移，一轮后，最大值在最大索引处

核心细节：比较的轮数 = 列表的长度 - 1

每轮比较的次数 = 列表的长度 - 1 - 轮数(从0开始)

比较内循环中 j 和 j+1 的元素

时间复杂度：最差 O( $n^{2}$ )，最优 O( n )

代码示例：

# 1、定义 冒泡排序 函数
def bubble_sort(my_list):
    """
    冒泡排序，对列表元素 进行排序
    :param my_list: 要被排序的列表
    :return: 无
    """
    # 1.1 定义变量：列表的长度
    n = len(my_list)
    # 1.2 遍历  外循环：比较的轮数
    for i in range(0, n-1):
        # 定义变量：交换的次数
        count = 0

        # 1.3 内循环：每轮比较的次数
        for j in range(0, n-i-1):
            # 1.4 对比 索引为 j 和 j+1 的元素
            if my_list[j] > my_list[j+1]:
                # 前值 大于 后值，两者交换
                count += 1      # 交换 1 次
                my_list[j], my_list[j+1] = my_list[j+1], my_list[j]     # 拆包
        # 节约资源：count为 0，说明无需交换 已是最终排序结果，结束循环
        if count == 0:
            break

# 2、在 main方法中测试
if __name__ == '__main__':
    # 3、定义要排序的列表
    my_list = [11, 44, 66, 33, 88, 66]
    print(f'排序前：{my_list}')
    # 4、调用 冒泡排序
    bubble_sort(my_list)
    # 5、 打印 排序结果
    print(f'排序后：{my_list}')

2. 插入排序

核心思想：将列表分为有序和无序，假设第1个元素为有序列表，其它元素为无序列表

从无序列表中依次拿值与有序列表中的值比较，小就往前放

时间复杂度：最差 O( $n^{2}$ )，最优 O( n )

代码示例：

# 1、定义 插入排序 函数
def insert_sort(my_list):
    """
    插入排序，对列表元素 进行排序
    :param my_list: 要被排序的列表
    :return: 无
    """
    # 1.1 获取列表的长度
    n = len(my_list)
    # 1.2 遍历 外循环：比较的轮数
    for i in range(1, n):
        # 1.3 内循环，从无序列表 逐个获取值，和有序列表的每个值比较
        for j in range(i, 0, -1):
            # 1.4 若无序中获取的值 比 有序中的值小，则交换
            if my_list[j] < my_list[j - 1]:
                my_list[j], my_list[j - 1] = my_list[j - 1], my_list[j]     # 拆包
            else:
                # 1.5 若 无序中获取的值 比 有序中的值大，则结束循环
                break

# 2、在 main方法中测试
if __name__ == '__main__':
    # 3、定义要排序的列表
    my_list = [11, 44, 66, 33, 88, 66]
    print(f'排序前：{my_list}')
    # 4、调用 插入排序
    insert_sort(my_list)
    # 5、打印排序结果
    print(f'排序后：{my_list}')

2、不稳定算法

1. 选择排序

核心思想：每轮选最小 or 最大的未排序元素放在序列的起始位置

核心细节：比较的轮数 = 列表的长度 - 1 = i

每轮比较的次数 = i + 1 到 n = j

比较最小值的索引（min_index）和 j 对应的元素

时间复杂度：最差 O( $n^{2}$ )，最优 O( n )

代码示例：

# 1、定义 选择排序 函数
def select_sort(my_list):
    """
    选择排序，对列表元素 进行排序
    :param my_list: 要被排序的列表
    :return: 无
    """
    # 1.1 获取列表的长度
    n = len(my_list)
    # 1.2 遍历 外循环：比较的轮数
    for i in range(0, n - 1):
        # 1.3 定义变量 min_index（最小值的索引）
        min_index = i
        # 1.4 内循环
        for j in range(i + 1, n):
            # 1.5 若 索引为 j 对应的元素 比 min_index 的元素小，将j的元素 赋值给 min_index
            if my_list[j] < my_list[min_index]:
                min_index = j       # min_index 永远记录: 最小值所在的位置(索引)

        # 1.6 判断 min_index的值是否有修改, 如果有修改, 说明最小值有变动, 交换即可
        if min_index != i:
            my_list[i], my_list[min_index] = my_list[min_index], my_list[i]     # 拆包


# 2、在 main方法中测试
if __name__ == '__main__':
    # 3、定义要排序的列表
    my_list = [11, 44, 66, 33, 88, 66]
    print(f'排序前：{my_list}')
    # 4、调用 选择排序
    select_sort(my_list)
    # 5、打印排序结果
    print(f'排序后：{my_list}')

2. 快速排序

核心思想：找分界值，比分界值小的放左边，大的放右边，以此类推

核心细节：对于左右两侧的数据，又可以分别取一个分界值进行独立排序

时间复杂度：最差 O( $n^{2}$ )，最优 O( nlogn )

代码示例：

# 1、定义 快速排序 函数
def quick_sort(my_list, start, end):    # start:0, end:列表长度 -1
    """
    快速排序，对列表元素 进行排序
    :param my_list: 要被排序的列表
    :param start: 起始索引
    :param end: 结束索引
    :return: 无
    """
    # 1.1 递归出口，只要 start >= end，说明排好顺序了，程序结束
    if start >= end:
        return
    # 1.2 假定第 1个元素 为分界值
    mid = my_list[start]
    # 1.3 定义游标，表示左边 和右边 的数据
    left = start
    right = end
    # 1.4 循环获取每个数据
    while left < right:
        # 1.5 将 >= 分界值 的数据 放右边
        while my_list[right] >= mid and left < right:
            right -= 1
        # 说明 右边的数据 < 分界值，放左边
        my_list[left] = my_list[right]

        # 1.6 将 < 分界值 的数据 放左边
        while my_list[left] < mid and left < right:
            left += 1
        # 说明 左边的数据 > 分界值，放右边
        my_list[right] = my_list[left]

    # 1.7 循环结束，找到分界值的位置
    my_list[left] = mid
    # 1.8 左边和右边的数据再独立排序，各自取分界值
    quick_sort(my_list, start, left - 1)
    quick_sort(my_list, right + 1, end)

# 2、在 main方法中测试
if __name__ == '__main__':
    # 3、定义要排序的列表
    my_list = [11, 44, 66, 33, 88, 66]
    print(f'排序前：{my_list}')
    # 4、调用 插入排序
    quick_sort(my_list, 0, len(my_list) - 1)
    # 5、打印排序结果
    print(f'排序后：{my_list}')