排序：数据组织艺术，揭秘高效管理的奥秘

后端

2023-12-04 15:34:51

排序算法：驾驭数据海洋的利器

数据时代的排序难题

在浩瀚的数据海洋中，如何管理和处理海量数据已成为信息时代的核心课题。数据排序，这项看似简单的操作，却扮演着至关重要的角色，帮助我们从杂乱无章的数据中提取有价值的信息。

排序算法：分类有序

排序是指将一组数据按照特定的顺序重新排列，让数据结构中的元素井然有序。在不同的场景下，我们使用不同的排序算法，让数据为我们所用。

常见排序算法

1. 选择排序： 宛如大海捞针，从一组数据中反复挑选最小的元素。时间复杂度为O(n^2)。

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]

2. 冒泡排序： 像泡沫一样上浮，不断交换相邻的元素。时间复杂度为O(n^2)。

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]

3. 插入排序： 就像插入一张牌，将元素逐个插入已排序的序列中。时间复杂度为O(n^2)。

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

4. 希尔排序： 分而治之，将数据分成若干个子序列，再逐个排序合并。时间复杂度为O(n^3/2)。

def shell_sort(arr):
    gap = len(arr) // 2
    while gap > 0:
        for i in range(gap, len(arr)):
            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

5. 快速排序： 分而治之，选取一个枢纽元素，将数据划分为两部分。时间复杂度为O(nlogn)，空间复杂度为O(logn)。

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

def partition(arr, low, high):
    pivot = arr[high]
    i = low - 1
    for j in range(low, high):
        if arr[j] <= pivot:
            i = i + 1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i + 1], arr[high] = arr[high], arr[i + 1]
    return i + 1

6. 堆排序： 构建一个堆数据结构，不断弹出堆顶元素，形成有序序列。时间复杂度为O(nlogn)，空间复杂度为O(1)。

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)

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