昨天 20:43 上海商学院算法工程师发布于重庆

关注

十大排序算法详解与实现

排序算法概述

排序算法是计算机科学中用于将一组数据按照特定顺序排列的算法。常见的排序顺序包括升序和降序。排序算法在数据处理、数据库操作、信息检索等领域有广泛应用。高效的排序算法能显著提升程序性能。

排序算法可以分为两大类：比较排序和非比较排序。比较排序通过比较元素间的大小关系进行排序，而非比较排序则利用数据的其他特性进行排序。常见的比较排序算法包括冒泡排序、选择排序、插入排序、归并排序、快速排序和堆排序。非比较排序算法包括计数排序、桶排序和基数排序。

冒泡排序

冒泡排序是一种简单的排序算法，通过重复遍历待排序的列表，比较相邻的元素并交换顺序错误的元素。每一轮遍历会将当前未排序部分的最大元素“冒泡”到正确的位置。

算法步骤：

从列表的第一个元素开始，比较相邻的两个元素。
如果前一个元素大于后一个元素，交换它们的位置。
对每一对相邻元素重复上述操作，直到列表末尾。
重复上述步骤，直到没有任何元素需要交换。

时间复杂度：

最坏情况：O(n2)
平均情况：O(n2)
最好情况：O(n)

代码示例：

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

选择排序

选择排序通过重复选择未排序部分的最小元素并将其放到已排序部分的末尾来实现排序。该算法简单直观，但效率较低。

算法步骤：

在未排序序列中找到最小元素。
将最小元素与未排序序列的第一个元素交换位置。
重复上述步骤，直到所有元素均排序完毕。

时间复杂度：

最坏情况：O(n2)
平均情况：O(n2)
最好情况：O(n2)

代码示例：

def selection_sort(arr):
    n = len(arr)
    for i in range(n):
        min_idx = i
        for j in range(i+1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

插入排序

插入排序通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序对于小规模或基本有序的数据效率较高。

算法步骤：

从第一个元素开始，该元素可以认为已经被排序。
取出下一个元素，在已经排序的元素序列中从后向前扫描。
如果该元素大于新元素，将该元素移到下一位置。
重复步骤3，直到找到已排序的元素小于或等于新元素的位置。
将新元素插入到该位置后。
重复步骤2~5，直到所有元素均排序完毕。

时间复杂度：

最坏情况：O(n2)
平均情况：O(n2)
最好情况：O(n)

代码示例：

def insertion_sort(arr):
    n = len(arr)
    for i in range(1, n):
        key = arr[i]
        j = i - 1
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr

归并排序

归并排序是一种分治算法，通过将列表分成两半，分别排序后再合并。归并排序效率高且稳定，适合大规模数据排序。

算法步骤：

将列表分成两半，递归地对每一半进行归并排序。
合并两个已排序的子列表，得到一个完整的有序列表。

时间复杂度：

最坏情况：O(n log n)
平均情况：O(n log n)
最好情况：O(n log n)

代码示例：

def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        left = arr[:mid]
        right = arr[mid:]
        merge_sort(left)
        merge_sort(right)
        i = j = k = 0
        while i < len(left) and j < len(right):
            if left[i] < right[j]:
                arr[k] = left[i]
                i += 1
            else:
                arr[k] = right[j]
                j += 1
            k += 1
        while i < len(left):
            arr[k] = left[i]
            i += 1
            k += 1
        while j < len(right):
            arr[k] = right[j]
            j += 1
            k += 1
    return arr

快速排序

快速排序是一种高效的分治排序算法，通过选择一个“基准”元素，将列表分为两部分，一部分小于基准，另一部分大于基准，然后递归地对这两部分进行排序。

算法步骤：

选择一个基准元素。
将列表分为两部分，一部分小于基准，另一部分大于基准。
递归地对两部分进行快速排序。

时间复杂度：

最坏情况：O(n2)
平均情况：O(n log n)
最好情况：O(n log n)

代码示例：

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    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)

堆排序

堆排序利用堆这种数据结构进行排序。堆是一种完全二叉树，分为最大堆和最小堆。堆排序通过构建最大堆，将堆顶元素与末尾元素交换并调整堆，实现排序。

算法步骤：

构建一个最大堆。
将堆顶元素与末尾元素交换。
减少堆的大小，并重新调整堆。
重复步骤2~3，直到堆的大小为1。

时间复杂度：

最坏情况：O(n log n)
平均情况：O(n log n)
最好情况：O(n log n)

代码示例：

def heapify(arr, n, i):
    largest = i
    left = 2 * i + 1
    right = 2 * i + 2
    if left < n and arr[i] < arr[left]:
        largest = left
    if right < n and arr[largest] < arr[right]:
        largest = right
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

def heap_sort(arr):
    n = len(arr)
    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)
    return arr

计数排序

计数排序是一种非比较排序算法，适用于整数排序。它通过统计每个元素的出现次数，然后根据统计结果将元素放回正确位置。

算法步骤：

找出待排序数组中的最大元素。
统计每个元素的出现次数。
根据统计结果将元素放回正确位置。

时间复杂度：

最坏情况：O(n + k)
平均情况：O(n + k)
最好情况：O(n + k)

代码示例：

def counting_sort(arr):
    max_val = max(arr)
    count = [0] * (max_val + 1)
    for num in arr:
        count[num] += 1
    sorted_arr = []
    for i in range(len(count)):
        sorted_arr.extend([i] * count[i])
    return sorted_arr

桶排序

桶排序将元素分配到有限数量的桶中，每个桶再分别排序。桶排序适用于元素均匀分布的情况。

算法步骤：

设置一个定量的数组作为空桶。
遍历输入数据，将每个元素放入对应的桶中。
对每个非空桶进行排序。
从非空桶中把元素拼接起来。

时间复杂度：

最坏情况：O(n2)
平均情况：O(n +

BbS.okacop030.info/PoSt/1120_772015.HtM
BbS.okacop031.info/PoSt/1120_505020.HtM
BbS.okacop032.info/PoSt/1120_039462.HtM
BbS.okacop033.info/PoSt/1120_101839.HtM
BbS.okacop034.info/PoSt/1120_285701.HtM
BbS.okacop035.info/PoSt/1120_333460.HtM
BbS.okacop036.info/PoSt/1120_653742.HtM
BbS.okacop037.info/PoSt/1120_420476.HtM
BbS.okacop038.info/PoSt/1120_904949.HtM
BbS.okacop039.info/PoSt/1120_128440.HtM
BbS.okacop030.info/PoSt/1120_508410.HtM
BbS.okacop031.info/PoSt/1120_042059.HtM
BbS.okacop032.info/PoSt/1120_403403.HtM
BbS.okacop033.info/PoSt/1120_688948.HtM
BbS.okacop034.info/PoSt/1120_439233.HtM
BbS.okacop035.info/PoSt/1120_609046.HtM
BbS.okacop036.info/PoSt/1120_983237.HtM
BbS.okacop037.info/PoSt/1120_914369.HtM
BbS.okacop038.info/PoSt/1120_299102.HtM
BbS.okacop039.info/PoSt/1120_219835.HtM
BbS.okacop030.info/PoSt/1120_185456.HtM
BbS.okacop031.info/PoSt/1120_705224.HtM
BbS.okacop032.info/PoSt/1120_398354.HtM
BbS.okacop033.info/PoSt/1120_657913.HtM
BbS.okacop034.info/PoSt/1120_051043.HtM
BbS.okacop035.info/PoSt/1120_018305.HtM
BbS.okacop036.info/PoSt/1120_293485.HtM
BbS.okacop037.info/PoSt/1120_141231.HtM
BbS.okacop038.info/PoSt/1120_905080.HtM
BbS.okacop039.info/PoSt/1120_364161.HtM
BbS.okacop030.info/PoSt/1120_373015.HtM
BbS.okacop031.info/PoSt/1120_473242.HtM
BbS.okacop032.info/PoSt/1120_661471.HtM
BbS.okacop033.info/PoSt/1120_478280.HtM
BbS.okacop034.info/PoSt/1120_733204.HtM
BbS.okacop035.info/PoSt/1120_352554.HtM
BbS.okacop036.info/PoSt/1120_194029.HtM
BbS.okacop037.info/PoSt/1120_269428.HtM
BbS.okacop038.info/PoSt/1120_638524.HtM
BbS.okacop039.info/PoSt/1120_878197.HtM
BbS.okacop030.info/PoSt/1120_379482.HtM
BbS.okacop031.info/PoSt/1120_178002.HtM
BbS.okacop032.info/PoSt/1120_181480.HtM
BbS.okacop033.info/PoSt/1120_570321.HtM
BbS.okacop034.info/PoSt/1120_451510.HtM
BbS.okacop035.info/PoSt/1120_631033.HtM
BbS.okacop036.info/PoSt/1120_349309.HtM
BbS.okacop037.info/PoSt/1120_451737.HtM
BbS.okacop038.info/PoSt/1120_949796.HtM
BbS.okacop039.info/PoSt/1120_675768.HtM
BbS.okacop040.info/PoSt/1120_555500.HtM
BbS.okacop041.info/PoSt/1120_555231.HtM
BbS.okacop042.info/PoSt/1120_931800.HtM
BbS.okacop043.info/PoSt/1120_706948.HtM
BbS.okacop044.info/PoSt/1120_215428.HtM
BbS.okacop045.info/PoSt/1120_895715.HtM
BbS.okacop046.info/PoSt/1120_942650.HtM
BbS.okacop047.info/PoSt/1120_054988.HtM
BbS.okacop048.info/PoSt/1120_808765.HtM
BbS.okacop049.info/PoSt/1120_529718.HtM
BbS.okacop040.info/PoSt/1120_099639.HtM
BbS.okacop041.info/PoSt/1120_468280.HtM
BbS.okacop042.info/PoSt/1120_591053.HtM
BbS.okacop043.info/PoSt/1120_890557.HtM
BbS.okacop044.info/PoSt/1120_349127.HtM
BbS.okacop045.info/PoSt/1120_930788.HtM
BbS.okacop046.info/PoSt/1120_966139.HtM
BbS.okacop047.info/PoSt/1120_980125.HtM
BbS.okacop048.info/PoSt/1120_483816.HtM
BbS.okacop049.info/PoSt/1120_444323.HtM
BbS.okacop040.info/PoSt/1120_886738.HtM
BbS.okacop041.info/PoSt/1120_751394.HtM
BbS.okacop042.info/PoSt/1120_132985.HtM
BbS.okacop043.info/PoSt/1120_602701.HtM
BbS.okacop044.info/PoSt/1120_770055.HtM
BbS.okacop045.info/PoSt/1120_902806.HtM
BbS.okacop046.info/PoSt/1120_261891.HtM
BbS.okacop047.info/PoSt/1120_574791.HtM
BbS.okacop048.info/PoSt/1120_506515.HtM
BbS.okacop049.info/PoSt/1120_741275.HtM