七大排序算法的Python实现

七大排序算法的Python实现

1. 冒泡排序 (Bubble Sort)

算法思想

冒泡排序通过重复交换相邻的未按顺序排列的元素来排序数组。每次迭代都将最大的元素“冒泡”到数组的末尾。

复杂度分析

• 时间复杂度: O(n^2)
• 空间复杂度: O(1)

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

2. 选择排序 (Selection Sort)

算法思想

选择排序通过反复找到未排序部分中的最小元素并将其放置在已排序部分的末尾来排序数组。

复杂度分析

时间复杂度: O(n^2)
空间复杂度: O(1)

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. 插入排序 (Insertion Sort)

算法思想

插入排序通过将未排序的元素插入到已排序部分的适当位置来排序数组。

复杂度分析

时间复杂度: O(n^2)
空间复杂度: O(1)

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

4. 归并排序 (Merge Sort)

算法思想

归并排序是一个分治算法，通过将数组递归地分成两半，分别排序，然后合并排序结果来排序数组。

复杂度分析

时间复杂度: O(n log n)
空间复杂度: O(n)

def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        L = arr[:mid]
        R = arr[mid:]

        merge_sort(L)
        merge_sort(R)

        i = j = k = 0

        while i < len(L) and j < len(R):
            if L[i] < R[j]:
                arr[k] = L[i]
                i += 1
            else:
                arr[k] = R[j]
                j += 1
            k += 1

        while i < len(L):
            arr[k] = L[i]
            i += 1
            k += 1

        while j < len(R):
            arr[k] = R[j]
            j += 1
            k += 1

    return arr

5. 快速排序 (Quick Sort)

算法思想

快速排序是一个分治算法，通过选择一个“基准”元素，将数组分成小于基准和大于基准的两个部分，分别排序，然后合并排序结果来排序数组。

复杂度分析

时间复杂度: O(n log n) 平均, O(n^2) 最坏
空间复杂度: O(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)

6. 堆排序 (Heap Sort)

算法思想

堆排序通过将数组构建成一个最大堆，然后反复从堆中取出最大元素并将其放置在数组的末尾来排序数组。

复杂度分析

时间复杂度: O(n log n)
空间复杂度: O(1)

def heapify(arr, n, i):
    largest = i
    l = 2 * i + 1
    r = 2 * i + 2

    if l < n and arr[i] < arr[l]:
        largest = l

    if r < n and arr[largest] < arr[r]:
        largest = r

    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

7. 希尔排序 (Shell Sort)

算法思想

希尔排序是插入排序的一种改进，通过比较相距一定间隔的元素来排序数组，然后逐渐缩小间隔，最终进行一次插入排序。

复杂度分析

时间复杂度: 最坏情况下 O(n^2)，平均情况下介于 O(n) 和 O(n^2) 之间
空间复杂度: O(1)

def shell_sort(arr):
    n = len(arr)
    gap = n // 2

    while gap > 0:
        for i in range(gap, n):
            temp = arr[i]
            j = i
            while j >= gap and arr[j - gap] > temp:
                arr[j] = arr[j - gap]
                j -= gap
            arr[j] = temp
        gap //= 2

    return arr