排序算法介绍(一)

排序算法

概述：

        就是按照顺序(升序, 降序), 把一串数据给排列起来.

分类: 

         稳定算法:

                 特点:

                         相同元素不会交换, 即:排序后, 相同的关键词会和原始数据保持 相对位置一致.

                 例如:

                         冒泡排序, 插入排序。

         不稳定算法:

                特点:

                         相同元素会交换。

                 例如:

                         选择排序, 快速排序。

冒泡排序:

        核心思想:

                 相邻元素两两比较, 大的往后走, 这样第一轮比较完毕后, 最大值就在最大索引处.

         核心细节:

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

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

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

        动图演示与代码:

# 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):           # i的值: 0, 1, 2, 3
        # 定义变量, count, 表示交换次数.
        count = 0

        # 1.3 内循环, 充当: 每轮比较的次数.
        for j in range(0, n - i - 1):   # j的值: 4, 3, 2, 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

选择排序

        核心思想:

                 每轮都从未排序的序列中, 找到最小(最大)值, 填充到排好序的位置(升序, 降序).

        核心细节:

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

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

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

        动图演示与代码:

# 1. 定义函数, 表示选择排序.
def select_sort(my_list):
    """
    自定义代码, 通过选择排序, 对列表元素进行排序.
    :param my_list: 要被排序的列表.
    :return: 无.
    """
    # 1.1 获取列表长度.
    n = len(my_list)   # 假设是: 5
    # 1.2 外循环, 控制: 比较的轮数
    for i in range(0, n - 1):                   # i的值: 0,           1,      2,   3,      四轮
        # 1.3 定义变量 min_index, 用来表示最小值的索引.
        min_index = i   # 假设第i个元素为: 最小值. 假设: 第1轮: 0最小.  第2轮: 1最小.  第3轮: 2最小.
        # 1.4 内循环, 控制每轮比较的次数.
        for j in range(i + 1, n):              # j的值: 1,2,3,4      2,3,4   3,4   4        每轮比较的次数
            # 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]

插入排序

        核心思想:

        将列表分成两个部分, 即: 假设第1个元素为有序列表, 其它元素为无序列表. 然后逐个获取无序列表中的值, 往有序列表中添加即可.

        动图演示与代码:

        

# 1. 定义函数, 实现: 插入排序.
def insert_sort(my_list):       # 假定: 5, 3, 4, 7, 2
    """
    自定义的排序算法, 通过插入排序的思路, 实现升序排列.
    :param my_list: 要被排序的列表.
    :return: 无
    """
    # 1.1 获取列表的长度.
    n = len(my_list)
    # 1.2 通过外循环, 表示: 有序列表(中的每个值),                               例如: 5    3,5
    for i in range(1, n):
        # 1.3 通过内循环, 依次从无序列表中逐个获取每个值, 然后和 有序列表的(每个)值进行比较. 例如: 3    4
        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

快速排序

        原理:

                找分界值, 比该值小的放左边, 比该值大的放右边, 以此类推, 直至最终排序完成.

                 第1轮: 1个分界值.

                第2轮: 2个分界值.

                 第3轮: 4个分界值.

                 ......

        核心思想:

                (1)首先设定一个分界值，通过该分界值将数组分成左右两部分

                (2)将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边 此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值

                (3)然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值， 将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也做类似处理

                (4)重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序 当左、右两个部分各数据排序完成后，整个数组的排序也就完成了

        动图演示与代码:

# 1. 定义函数, 实现: 插入排序.
def quick_sort(my_list, start, end):       # start:0,  end: 列表长度-1
    """
    自定义的排序算法, 通过快速排序的思路, 实现升序排列.
    :param my_list: 要被排序的列表.
    :param start: 起始索引, 即: 从哪开始排序
    :param end:   结束索引, 即: 到哪结束排序, 通过start - end标记一段数据.
    :return: 无
    """
    # 1.1 递归出口, 只要start >= end, 说明排好顺序了, 程序结束.
    if start >= end:
        return
    # 1.2 定义分界值, 假定第1个元素为分界值.
    mid = my_list[start]    # 默认: mid = my_list[0]
    # 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)