八大排序算法 (python版本)

已于 2023-08-29 22:21:41 修改
阅读量264 收藏 1
点赞数
分类专栏： LeetCode 文章标签： 排序算法 python 算法
于 2023-08-27 17:23:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45056135/article/details/132524829
版权

八大排序算法

个人学习笔记 如有问题欢迎指正交流

快速排序经常考， 如果只掌握一个排序算法的话，首选快速排序算法
八大排序算法通常指的是以下八种经典排序算法：

1. 冒泡排序 (Bubble Sort)

  • 使用场景：适用于小规模数据的排序，不推荐用于大规模数据排序。
  • 稳定性：稳定排序算法。
  • 时间复杂度：平均和最坏情况下 O(n^2)，最好情况下 O(n)（当输入数据已经有序时）。

2. 选择排序 (Selection Sort):

  • 使用场景：适用于小规模数据的排序，与冒泡排序类似，不适用于大规模数据排序。
  • 稳定性：不稳定排序算法。
  • 时间复杂度：都为 O(n^2)。

3. 插入排序 (Insertion Sort):

  • 使用场景：适用于小规模数据，也适用于部分有序的大规模数据。
  • 稳定性：稳定排序算法。
  • 时间复杂度：平均和最坏情况下 O(n^2)，最好情况下 O(n)（当输入数据已经有序时）。

4. 希尔排序 (Shell Sort):

  • 使用场景：适用于中等规模数据，对于大规模数据效果也不错。
  • 稳定性：不稳定排序算法。
  • 时间复杂度：最坏情况下取决于间隔序列，通常介于 O(n log n) 和 O(n^2) 之间。

5. 归并排序 (Merge Sort):

  • 使用场景：适用于大规模数据，对数据规模不敏感，效率稳定。
  • 稳定性：稳定排序算法。
  • 时间复杂度：始终为 O(n log n)，但需要额外的空间来存储中间结果。

6. 快速排序 (Quick Sort):

  • 使用场景：适用于大规模数据，且在大多数情况下效率较高。
  • 稳定性：不稳定排序算法。
  • 时间复杂度：平均情况下 O(n log n)，最坏情况下 O(n^2)（当选择的主元极不均匀时）。

7. 堆排序 (Heap Sort):

  • 使用场景：适用于大规模数据，且对内存要求较高，适合外部排序。
  • 稳定性：不稳定排序算法。
  • 时间复杂度：始终为 O(n log n)，且不需要额外空间。

8. 计数排序 (Counting Sort):

  • 使用场景：适用于数据范围不大，但是数据量较大的情况。
  • 稳定性：稳定排序算法。
  • 时间复杂度：最好情况下为 O(n + k)，其中 k 表示数据范围。

每种排序算法都有其独特的应用场景和特点，根据实际问题选择合适的排序算法能够有效提高程序的效率。

1. 冒泡排序

在这里插入图片描述

图1摘自菜鸟教程
  1. 冒泡排序(相邻比较冒泡) 遍历i时 (0, n-i)进行比较 (n-i, n)是有序的
    1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
    2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
      针对所有的元素重复以上的步骤，除了最后一个。

复杂度: O(n^2)
稳定性：稳定排序算法。
使用场景：适用于小规模数据的排序，不推荐用于大规模数据排序。
详细介绍: https://www.runoob.com/w3cnote/bubble-sort.html
视频讲解: https://www.bilibili.com/video/BV1Hg4y1q7tz

"""
1.冒泡排序(相邻比较冒泡) 遍历i次之后 (0, n-i)进行比较 (n-i, n)是有序的
    1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
    2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
    针对所有的元素重复以上的步骤，除了最后一个。
复杂度: O(n^2)
稳定性：稳定排序算法。
使用场景：适用于小规模数据的排序，不推荐用于大规模数据排序。
详细介绍: https://www.runoob.com/w3cnote/bubble-sort.html
视频讲解: https://www.bilibili.com/video/BV1Hg4y1q7tz
"""
def bubble_sort(arr):
    for i in range(len(arr)):
        flag = True
        for j in range(len(arr)-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
                flag = False
        if flag:
            break
    return arr

if __name__ == '__main__':
    arr = [5, 4, 3, 2, 1]
    res = bubble_sort(arr)
    print(f"res: {res}")

2. 选择排序

在这里插入图片描述

图2摘自菜鸟教程
  1. 选择排序 遍历i次之后 操作(0, i)是有序的 (i, n) 进行比较
    (选择最小(最大)的在未排序的最开始(末尾)位置) 针对(i, n)进行的排序
    1. 在每一轮循环中，找到未排序部分中的最小元素的索引，然后将最小元素与当前位置进行交换。
    2. 每一轮循环会将一个最小元素放到已排序部分的末尾。

复杂度: O(n^2)
稳定性：不稳定排序算法。
使用场景：适用于小规模数据的排序，与冒泡排序类似，不适用于大规模数据排序。
详细介绍: https://www.runoob.com/w3cnote/selection-sort.html
视频讲解: https://www.bilibili.com/video/BV1VK4y1475t

"""
2.选择排序 遍历i次之后 操作(0, i)是有序的 (i, n) 进行比较
    (选择最小(最大)的在未排序的最开始(末尾)位置) 针对(i, n)进行的排序
    1.在每一轮循环中，找到未排序部分中的最小元素的索引，然后将最小元素与当前位置进行交换。
    2.每一轮循环会将一个最小元素放到已排序部分的末尾。
复杂度: O(n^2)
稳定性：不稳定排序算法。
使用场景：适用于小规模数据的排序，与冒泡排序类似，不适用于大规模数据排序。
详细介绍: https://www.runoob.com/w3cnote/selection-sort.html
视频讲解: https://www.bilibili.com/video/BV1VK4y1475t
"""
def select_sort(arr):
    # l = 0
    n = len(arr)
    for i in range(n):
        min_index = i
        min = arr[i]
        for j in range(i+1, n):
            if arr[j] < min:
                min = arr[j]
                min_index = j
        print(f"l:flag_index {i}:{min_index}")
        arr[i], arr[min_index] = arr[min_index], arr[i]

    return arr
if __name__ == '__main__':
    arr = [9, 5, 2, 7, 12, 4]
    print(f"before: {arr}")
    res = select_sort(arr)
    print(f"res: {res}")

3. 插入排序

在这里插入图片描述

图2摘自菜鸟教程
  1. 插入排序
    遍历i时 (0, i-1)是有序的 将i插入到(0, i-1)序列中 (i, n)无序的
    找到一个合适的所用在(0, i-1) 中找到一个合适的位置进行插入
    1. 在每一轮循环中，找到未排序部分中的最小元素的索引，然后将最小元素与当前位置进行交换。
    2. 每一轮循环会将一个最小元素放到已排序部分的末尾。

复杂度: O(n^2)
稳定性：稳定排序算法。
使用场景：适用于小规模数据，也适用于部分有序的大规模数据。
详细介绍: https://www.runoob.com/w3cnote/insertion-sort.html
视频讲解: https://www.bilibili.com/video/BV1TD4y1Q751

"""
3.插入排序
    遍历i时 (0, i-1)是有序的 将i插入到(0, i-1)序列中   (i, n)无序的
    找到一个合适的所用在(0, i-1) 中找到一个合适的位置进行插入
    1.在每一轮循环中，找到未排序部分中的最小元素的索引，然后将最小元素与当前位置进行交换。
    2.每一轮循环会将一个最小元素放到已排序部分的末尾。
复杂度: O(n^2)
稳定性：稳定排序算法。
使用场景：适用于小规模数据，也适用于部分有序的大规模数据。
详细介绍: https://www.runoob.com/w3cnote/insertion-sort.html
视频讲解: https://www.bilibili.com/video/BV1TD4y1Q751
"""
def insert_sort(arr):
    n = len(arr)
    for i in range(1, n):
        preIndex = i-1
        current = arr[i]
        # 大于current的元素向右移动
        while preIndex >= 0 and arr[preIndex] > current:
            arr[preIndex+1] = arr[preIndex]
            preIndex -= 1
        arr[preIndex+1] = current
    print(f"arr: {arr}")
    return current

if __name__ == '__main__':
    arr = [10, 8, 11, 7, 4, 12]
    insert_sort(arr)

4 希尔排序

在这里插入图片描述

图4摘自博客园

4.希尔排序 (gap为1就是插入排序)
希尔排序的基本思想是
1. 将数组中相距一定间隔(gap)的元素分成一组，
2. 对每组使用插入排序，然后逐步减小间隔直至为1，最终完成排序。

稳定性：不稳定排序算法。
使用场景：适用于中等规模数据，对于大规模数据效果也不错。
复杂度: 最坏情况下取决于间隔序列，通常介于 O(nlog n)和 O(n^2) 之间。
详细介绍: https://www.runoob.com/w3cnote/shell-sort.html
视频讲解: https://www.bilibili.com/video/BV1BK4y1478X

"""
4.希尔排序 (gap为1就是插入排序) 
    希尔排序的基本思想是
    1. 将数组中相距一定间隔(gap)的元素分成一组，
    2. 对每组使用插入排序，然后逐步减小间隔直至为1，最终完成排序。

稳定性：不稳定排序算法。
使用场景：适用于中等规模数据，对于大规模数据效果也不错。
复杂度: 最坏情况下取决于间隔序列，通常介于 O(nlog n)和 O(n^2) 之间。
详细介绍: https://www.runoob.com/w3cnote/shell-sort.html
视频讲解: https://www.bilibili.com/video/BV1BK4y1478X
"""

def shell_sort(arr):
    n = len(arr)
    gap = n // 3
    while gap > 0:
        for i in range(gap, n):  # 从gap开始因为要从第二个开始插入, 第一个元素已经是有序的
            current = arr[i]
            preIndex = i - gap
            while preIndex >= 0 and arr[preIndex] > current:
                arr[preIndex+gap] = arr[preIndex]
                preIndex -= gap
            arr[preIndex+gap] = current
        gap //= 2
    return arr

if __name__ == '__main__':
    # 测试
    arr = [12, 34, 54, 2, 3]
    shell_sort(arr)
    print("排序后的数组：", arr)

5. 归并排序

在这里插入图片描述

图5摘自菜鸟教程
  1. 归并排序算法步骤: (递归和栈)
    1. 先归(一致分)
    2. 然后并(比较排序)

时间复杂度：O(nlogn)但需要额外的空间来存储中间结果。
稳定性：稳定排序算法。
使用场景：适用于大规模数据，对数据规模不敏感，效率稳定。
复杂度: O(nlogn)
详细介绍: https://www.runoob.com/w3cnote/merge-sort.html
视频讲解: https://www.bilibili.com/video/BV1Pt4y197VZ

"""
5. 归并排序 (递归和栈)
    1. 先归(一致分)
    2. 然后并(比较排序)

时间复杂度：O(nlogn)但需要额外的空间来存储中间结果。
稳定性：稳定排序算法。
使用场景：适用于大规模数据，对数据规模不敏感，效率稳定。
复杂度: O(nlogn)
详细介绍: https://www.runoob.com/w3cnote/merge-sort.html
视频讲解: https://www.bilibili.com/video/BV1Pt4y197VZ
"""
def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = arr[:mid]
    right = arr[mid:]
    # 归
    left = merge_sort(left)
    right = merge_sort(right)

    return merge(left, right) # 并
def merge(left, right): # left, right都是有序数组
    i = j = 0
    res_list = []
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            res_list.append(left[i])
            i += 1
        else:
            res_list.append(right[j])
            j += 1
    res_list.extend(left[i:])
    res_list.extend(right[j:])
    return res_list



if __name__ == '__main__':
    # 测试
    arr = [12, 11, 13, 5, 6, 7]
    sorted_arr = merge_sort(arr)
    print("排序后的数组：", sorted_arr)

6. 快速排序(重点!!!)

在这里插入图片描述

图6摘自菜鸟教程

算法步骤:

  1. 从数列中挑出一个元素，称为 “基准”（pivot）;
  2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

复杂度: O(nlogn) 最坏情况下 O(n^2) (当选择的主元极不均匀时)。
稳定性：不稳定排序算法。
使用场景：适用于大规模数据，且在大多数情况下效率较高。
详细介绍: https://www.runoob.com/w3cnote/quick-sort-2.html
视频讲解: https://www.bilibili.com/video/BV1WF41187Bp

6.1 方法1:

"""
6. 快速排序 是一种分治算法，
    它选择一个基准元素，将数组分成两个子数组，
    分别小于和大于基准元素，
    然后对子数组进行递归排序。
复杂度: O(nlogn) 最坏情况下 O(n^2) (当选择的主元极不均匀时)。
稳定性：不稳定排序算法。
使用场景：适用于大规模数据，且在大多数情况下效率较高。
详细介绍: https://www.runoob.com/w3cnote/quick-sort-2.html
视频讲解: https://www.bilibili.com/video/BV1WF41187Bp
"""
def quick_sort(arr):
    if len(arr) <= 1:
        return arr

    pivot = arr[len(arr)-1]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]

    return quick_sort(left) + middle + quick_sort(right)

if __name__ == '__main__':
    # arr =
    arr = [5, 3, 4, 2, 1]
    sorted_arr = quick_sort(arr)
    print("排序后的数组：", sorted_arr)

6.2 方法2:

"""
6. 快速排序 是一种分治算法，
    它选择一个基准元素，将数组分成两个子数组，
    分别小于和大于基准元素，
    然后对子数组进行递归排序。
复杂度: O(nlogn)
详细介绍: https://www.runoob.com/w3cnote/quick-sort-2.html
视频讲解: https://www.bilibili.com/video/BV1WF41187Bp
"""


def quick_sort(arr, low, high):
    if low < high:
        pivot_index = partition(arr, low, high)
        quick_sort(arr, low, pivot_index-1)
        quick_sort(arr, pivot_index + 1, high)

# 进行分区， 返回分区后pivot的坐标pivotIndex的 左边都小于等于pivot, 右边都大于等于pivot
# 退出循环时 right + 1 = left, arr[right] <= pivot arr[right+1] >= pivot 所以 low 和 right 交换值
def partition(arr, low, high):
    pivot = arr[low]								# 基点
    left = low + 1
    right = high
    flag = False
    #  退出循环的时候 arr[r]指向的肯定是小于pivot
    while True:
        while left <= right and arr[left] <= pivot:		# 这里不使用等号可能出现死循环 [5, 5] /[5, 6, 5, 1]
            left = left + 1
        while left <= right and arr[right] >= pivot:   # 这里不使用等号可能出现死循环
            right = right - 1
        if right < left:
            break
        else:
            arr[left], arr[right] = arr[right], arr[left]

    arr[low], arr[right] = arr[right], arr[low]
    return right

# # 示例
# unsorted_list = [3, 6, 8, 10, 1, 2, 1]
# quick_sort(unsorted_list, 0, len(unsorted_list) - 1)
# print(unsorted_list)  # 输出：[1, 1, 2, 3, 6, 8, 10]

if __name__ == '__main__':
    # arr = [12, 11, 13, 5, 6, 7]
    # sorted_arr = quick_sort(arr)
    # print("排序后的数组：", sorted_arr)
    nums = [5, 3, 4, 2, 1]
    # nums = [12, 11, 13, 5, 6, 7]
    # nums = [3, 6, 8, 10, 1, 2, 1]
    quick_sort(nums, 0, len(nums)-1)
    print("nums: ", nums)

7. 堆排序

在这里插入图片描述

图7摘自菜鸟教程
  1. 堆排序
    1. 维护堆的性质 复杂度O(logn)
      父节点大于等于左孩子与右孩子， 不满足的话依次和左孩子进行交换
    2. 建立大顶堆， 倒序依次遍历父节点n//2 -1 建立大顶堆
    3. 堆排序
      逐个从堆中提取最大值，并将其放置到已排序部分的末尾。
      提取的方式是将根节点与最后一个节点交换，然后对根节点进行堆化。

复杂度：始终为O(nlogn)，且不需要额外空间。
稳定性：不稳定排序算法。
使用场景：适用于大规模数据，且对内存要求较高，适合外部排序。
详细介绍: https://www.runoob.com/w3cnote/heap-sort.html
视频讲解: https://www.bilibili.com/video/BV1fp4y1D7cj

"""
7. 堆排序
    1. 维护堆的性质 复杂度O(logn)
    父节点大于等于左孩子与右孩子， 不满足的话依次和左孩子进行交换
    2. 维护大顶堆， 倒序依次遍历父节点  建立大顶堆
    3. 堆排序
    逐个从堆中提取最大值，并将其放置到已排序部分的末尾。
    提取的方式是将根节点与最后一个节点交换，然后对根节点进行堆化。
    
复杂度：始终为O(nlogn)，且不需要额外空间。
稳定性：不稳定排序算法。
使用场景：适用于大规模数据，且对内存要求较高，适合外部排序。
详细介绍: https://www.runoob.com/w3cnote/heap-sort.html
视频讲解: https://www.bilibili.com/video/BV1fp4y1D7cj
"""

def heapify(arr, n, i):     # 1.用来维护堆的性质
    """
    :param arr: 存储堆的数组
    :param n:   数组长度
    :param i:   待维护节点的下标
    :return:
    """
    largest = i         # 初始化最大元素索引为根节点
    lson = 2 * i + 1    # 左子节点索引
    rson = 2 * i + 2   # 右子节点索引

    # 找到左右子节点中较大的索引
    if lson < n and arr[lson] > arr[largest]:
        largest = lson
    if rson < n and arr[rson] > arr[largest]:
        largest = rson

    # 如果最大值不是根节点，则交换根节点与最大值
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        # 递归对受影响的子树进行堆化
        heapify(arr, n, largest)

# 堆排序
def heap_sort(arr):
    n = len(arr)

    # 倒序依次遍历父节点，通过维护堆的性质， 构建大顶堆 注意这里n是数组长度而不是索引
    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)

    # 一个个提取元素从堆排序
    for i in range(n - 1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]  # 交换根节点与最后一个节点
        heapify(arr, i, 0)  # 对剩余的堆进行堆化, 这里传入的是i, 交换之后已经脱离了

if __name__ == '__main__':
    # 示例
    unsorted_list = [12, 11, 13, 5, 6, 7]
    heap_sort(unsorted_list)
    print(unsorted_list)  # 输出：[5, 6, 7, 11, 12, 13]

8 计数排序

在这里插入图片描述

图8摘自菜鸟教程
  1. 堆排序
    适用场景: 计数排序要求输入的数据必须是有确定范围的整数。
    （1）找出待排序的数组中最大和最小的元素
    （2）统计数组中每个值为i的元素出现的次数，存入数组C的第i项
    （3）对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
    （4）反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1

稳定性：稳定排序算法。
复杂度: 最好情况下为O(n+k)，其中 k 表示数据范围。
使用场景：适用于数据范围不大，但是数据量较大的情况。
详细介绍: https://www.runoob.com/w3cnote/counting-sort.html
视频讲解: https://www.bilibili.com/video/BV1KU4y1M7VY

"""
8. 堆排序
    适用场景: 计数排序要求输入的数据必须是有确定范围的整数。
    （1）找出待排序的数组中最大和最小的元素
	（2）统计数组中每个值为i的元素出现的次数，存入数组C的第i项
	（3）对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
	（4）反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1

稳定性：稳定排序算法。
复杂度: 最好情况下为O(n+k)，其中 k 表示数据范围。
使用场景：适用于数据范围不大，但是数据量较大的情况。
详细介绍: https://www.runoob.com/w3cnote/counting-sort.html
视频讲解: https://www.bilibili.com/video/BV1KU4y1M7VY
"""
def countingSort(arr):
    maxValue = float("-inf")
    for element in arr:
        maxValue = max(maxValue, element)

    maxLen = maxValue+1
    countArray = [0] * maxLen
    sortedIndex = 0

    arrLen = len(arr)
    for i in range(arrLen):
        # if not bucket[arr[i]]:
        #     bucket[arr[i]]=0
        countArray[arr[i]] += 1
    print(countArray)
    for j in range(maxLen):
        while countArray[j] > 0:
            arr[sortedIndex] = j
            sortedIndex += 1
            countArray[j] -= 1
    return arr
if __name__ == '__main__':
    # 示例
    unsorted_list = [12, 11, 13, 5, 6, 7]
    countingSort(unsorted_list)
    print(unsorted_list)  # 输出：[5, 6, 7, 11, 12, 13]

总结

稳定的排序方法有：
冒泡排序、插入排序、归并排序、计数排序。

不稳定的排序方法有
选择排序， 希尔排序， 快速排序， 堆排序

对于数据量少的情况
通常使用
插入排序或冒泡排序，因为它们的常数因子较小，适用于小规模数据集。

对于数据量较大的情况

  1. 归并排序：适用于大规模数据，效率稳定，但需要额外的内存空间。
  2. 快速排序：适用于大规模数据，平均情况下效率较高，但在最坏情况下可能会退化为 O(n^2)。
  3. 堆排序：适用于大规模数据，不需要额外空间，但常数因子较大，效率稍低于快速排序。

数据范围不大，数据量较大的情况

计数排序适用于数据范围不大，数据量较大的情况，但由于它需要额外的数组存储计数信息，所以适用场景相对有限。
在实际应用中，根据数据量大小、稳定性要求、时间复杂度等因素综合考虑，选择适合的排序方法能够提高程序的性能。
快速排序经常考， 如果只掌握一个排序算法的话，首选快速排序算法

CodeWang_NC
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
快速排序的python实现
qq_41413211的博客
11-24 319
对写法二进行优化：原本的写法pivot是固定的，但是从数学的角度分析，如果数组本身就是升序或者降序，还进行快速排序，那么每次 partition 分区后子数组大小极不平衡，将退化成 O(n^2) 的时间复杂度算法。我们需要对上述代码进行优化，随机选择一个基点做为比较，称为随机化快速排序算法。注意：pivot是比较的起点，partition函数会让pivot左边都小于pivot，右边都大于pivot。写法二：推荐，可以迁移到其他算法中。写法一：简单，但是扩展性不强。
Python实现八大排序算法
01-20
如何用Python实现八大排序算法 1、插入排序 描述 插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为 O(n^2)。是稳定...
如何用Python实现快速排序
qq_28245087的博客
05-25 2113
快速排序是一种实用的排序算法，它的时间复杂度相对较低，而且可以在大部分情况下保持较好的性能。在Python中，我们可以使用递归的方式实现快速排序。同时，我们还可以定义一个用于比较两个元素大小的函数来优化快速排序的性能。
Python实现快速排序
热门推荐
qq_51201337的博客
03-07 1万+
快速排序的流程： (1) 从数列中挑出一个基准值。 (2) 将所有比基准值小的摆放在基准前面，所有比基准值大的摆在基准的后面(相同的数可以到任一边)；在这个分区退出之后，该基准就处于数列的中间位置。 (3) 递归地把"基准值前面的子数列"和"基准值后面的子数列"进行排序。
python实现快速排序算法
flyingluohaipeng的博客
02-21 2944
快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。因此，在到达大小为一的数列前，我们只要作log n次嵌套的调用。这个意思就是调用树的深度是O(log n)，则总体的最优时间复杂度为：O(nlogn)在最好的情况，每次我们运行一次分区，我们。
排序算法的巅峰之选：学习Python快速排序！
最新发布
子午的博客
07-06 856
本文介绍了快速排序算法的原理和实现，并提供了相关的Python代码示例。快速排序是一种高效的排序算法，在大多数情况下表现良好。然而，在最坏情况下，其性能可能下降。为了避免最坏情况的发生，可以采用随机选择基准元素和三数取中法选择基准元素的优化方法。另外，对于小规模的数据，可以使用插入排序进行优化。通过掌握快速排序的原理和优化思路，我们可以更好地理解和应用这一经典的排序算法。
八大排序算法的Python实现
12-23
Python实现八大排序算法，具体内容如下 1、插入排序 描述 插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。...
python实现八大常见排序算法
12-21
文章目录常见的排序算法冒泡排序选择排序插入排序希尔排序归并排序快速排序计数排序基数排序 常见的排序算法 冒泡排序 每次比较相邻两个数的大小，如果不是预期排序就交换顺序。 import random def bubble_sort...
使用 Python 实现快速排序算法
m0_59649695的博客
05-23 2472
上述实现中，需首先判断数组的长度是否小于等于 1，如果是，则直接返回该数组。否则，我们选择数组的第一个元素作为枢轴（pivot），并将数组中比枢轴小的元素放入左边的列表中，将比枢轴大的元素放入右边的列表中。然后，递归地对左边的列表和右边的列表进行快速排序，并将它们和枢轴一起合并起来。最终得到的数组就是有序的。快速排序是一种高效的排序算法，它采用分治法的思想进行排序。
python排序算法——快速排序（附代码）
阿极的博客
01-15 3184
（附详细代码）快速排序的平均时间复杂度是O(nlgn)，最好情况下的时间复杂度是O(nlgn)。最坏情况下，快速排序的时间复杂度可能退化成O( n2 )，但这种情况很少见。它的空间复杂度是O(nlgn)。它是一个不稳定的排序算法。
用python实现快速排序法
范枝洲的博客
02-15 1009
python 实现 快速排序算法
python实现快排_Python 实现快排
weixin_39618824的博客
12-09 181
快速排序简介快速排序，又称划分交换排序，从无序队列中挑取一个元素，把无序队列分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。简单来说：挑元素、划分组、分组重复前两步快速排序原理示意图通过上面对快速排序的简介，我们知道了，快速排序主要包括以下两方面：挑元素划分组、整体递归分组...
【Python算法系列十一】二叉树的3种遍历方式
m0_70372647的博客
05-26 1357
二叉树的遍历是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。 遍历二叉树的方法主要分 3 种：先序遍历、中序遍历和后序遍历： 先序遍历指最先遍历节点本身，再遍历节点的左子树，最后遍历右子树的遍历方法； 中序遍历指最先遍历节点的左子树，再遍历节点本身，最后遍历右子树的遍历方法； 后序遍历指最先遍历节点的左子树，再遍历右子树，最后遍历节点本身的一种遍历方法。 在图 1 中，L 是左子树，R 是右子树，D 当前节点。如果用这三个字母来表示 3 种遍历.
python实现快速排序
weixin_42264992的博客
05-28 329
python实现快速排序
Python代码实现快速排序
lubuhan的博客
10-28 815
Python代码实现快速排序
遗传算法实现八皇后问题python
04-04
以下是遗传算法实现八皇后问题的Python代码： ```python import random # 棋盘大小 BOARD_SIZE = 8 # 种群大小 POPULATION_SIZE = 100 # 繁殖代数 GENERATIONS = 1000 # 交叉概率 CROSSOVER_RATE = 0.8 # 变异...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值