Python中的四种排序算法

什么是排序?

排序: 使一串记录，按照其中的某个或某些关键字的大小递增递减

什么是排序算法?

排序算法: 使记录递增递减的方法

排序算法的重要性

        在大量数据的处理方面：一个优秀的算法可以节省大量的资源。

        在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量

的推理和分析

四种排序算法:

1.冒泡算法

什么是冒泡:

        冒泡排序:重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到

小、首字母从从Z到A）错误 就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素

需要交换，也就是说该元素列已经排序完成

        冒泡排序属于稳定算法

核心细节:

        比较的轮数: 列表的长度 -1

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

        谁和谁比较: 内循环假设是j,则是: j 和 j+1 的元素对比

代码如下:

# 1.定义函数,表示冒泡排序
def bubble_sort(my_list):   # my_list 是要被排序的列表
    # 1.1定义变量,记录列表的长度
    n = len(my_list)
    # 1.2开始排序,遍历, 外循环:比较的轮数
    for i in range(0,n-1):
        # 定义变量,count,表示交换次数
        count = 0

        # 1.3 内循环,充当:每轮比较的次数
        for j in range(0,n-1-i):
            # 1.4 具体的比较过程,j 和 j +1 的元素对比
            if my_list[j] > my_list[j + 1]:
                # 走这里,是具体的交换动作
                count += 1   # 表示交换一次
                my_list[j],my_list[j+1] = my_list[j+1],my_list[j]
        # 走这里,说明已经是最终排序了,无需交换了
        if count == 0:
            break

# 2.main函数中测试
if __name__ == '__main__':
    #3.定义列表，记录: 要排序的元素.
    my_list = [11,33,55,22,44]
    print(f'排序前:{my_list}')
    # 4。 调用 排序算法，对列表元素排序.
    bubble_sort(my_list)
    # 5，打印排序结果
    print(f'排序后:{my_list}')

2.选择排序

什么是选择排序?

        第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，

然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾. 以 此类推，

直到全部待排序的数据元素的个数为零.

        选择排序属于不稳定算法

核心细节:    

        比较的轮数: 列表的长度 - 1, 假设用 i 表示

        

        每轮比较的次数: i + 1 到 n, 假设用 j 表示

        谁和谁比较: min_index(最小值的索引) 和 j 对应的元素比较.

代码如下:

# 1.定义函数,表示选择排序
def select_sort(my_list):   # my_list 是要被排序的列表
    # 1.1定义变量,获取列表的长度
    n = len(my_list)   # 假设是5
    # 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,33,55,22,44]
    print(f'排序前:{my_list}')
    # 4。 调用 排序算法，对列表元素排序.
    select_sort(my_list)
    # 5，打印排序结果
    print(f'排序后:{my_list}')

3.插入排序

什么是插入排序?

        插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的

个数加一的有序数据， 算法适用于少量数据的排序

        插入排序属于稳定算法

插入排序的组成

        插入算法把要排序的数组分成两部分：

        第一部分是有序的数字(这里可以默认数组第一个数字为有序的第一部分)

        第二 部分为无序的数字(这里除了第一个数字以外剩余的数字可以认为是无序的第二部分)

核心细节:

        

        外循环:for i in range(1, n)

                内循环: for jin range(i, 0, -1)

                第1次: 1和0

                第2次: 2和1，1和0

                第3次: 3和2

                第4次: 4和3 ,3和2 ,2和1,1和0

代码如下:

# 1.定义函数,插入排序
def insert_sort(my_list):
    # 1.1 获取列表的长度.
    n = len(my_list)
    # 1.2 通过外循环，表示: 有序列表(中的每个值)
    for i in range(0,n):
        # 1.3 通过内循环，依次从无序列表中逐个获取每个值，然后和 有序列表的(每个)值进行比较。
        for j in range(i,0,-1): # 中间不写-1,写0,因为后续有个j-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__':
    # 2.1 定义列表，记录要排序的数据。
    my_list = [5, 3, 4, 7, 2]
    # 2.2 打印排序前的结果。
    print(f'排序前:{my_list}')
    # 2.3 排序
    insert_sort(my_list)
    # 2.4 打印排序后的结果。
    print(f'排序后:{my_list}')

4.快速排序

什么是快速排序?

        通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分

的所有数据都 要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归

进行，以此达到整个数据变成有序 序列

        快速排序属于不稳定算法

核心细节:

         找分界值， 比该值小的放左边， 比该值大的放右边，以此类推， 直至最终持序定成

        第1轮:1个分界值

        

        第2轮:2个分界值 第3轮: 4个分界值...

代码如下:

# 1.定义函数,插入排序
def quick_sort(my_list,start,end):
    """

    :param my_list:要被排序的列表
    :param start:起始索引，即:从哪开始排序
    :param end:结束索引，即:到哪结束排序，通过start - end标记一段数
    :return:无
    """
    # 1.1递归出口,只要start >= end,说明拍好顺序了,程序结束
    if start >= end:
        return
    # 1.2定义分界值,鉴定第一个元素为分界值
    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__':
    # 2.1 定义列表，记录要排序的数据。
    my_list = [5, 3, 4, 7, 2]
    # 2.2 打印排序前的结果。
    print(f'排序前:{my_list}')
    # 2.3 排序
    quick_sort(my_list,0,4)
    # 2.4 打印排序后的结果。
    print(f'排序后:{my_list}')