数据结构与算法终极指南：从理论到Python实战-CSDN博客

# 常见时间复杂度示例
def constant_time():      # O(1)
    print("Hello World")

def linear_time(n):       # O(n)
    for i in range(n):
        print("Hello")

def quadratic_time(n):    # O(n²)
    for i in range(n):
        for j in range(n):
            print("World")

时间复杂度层级：

O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(2ⁿ) < O(n!)

1.3 空间复杂度：内存占用评估

def space_complexity(n):
    lst = [0] * n  # O(n) 空间
    matrix = [[0]*n for _ in range(n)]  # O(n²) 空间

二、核心查找算法详解

2.1 顺序查找（线性查找）

def linear_search(lst, target):
    for idx, val in enumerate(lst):
        if val == target:
            return idx
    return -1

时间复杂度：O(n)
适用场景：无序数据集合

2.2 二分查找（折半查找）

def binary_search(lst, target):
    left, right = 0, len(lst)-1
    while left <= right:
        mid = (left + right) // 2
        if lst[mid] == target:
            return mid
        elif lst[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

时间复杂度：O(log n)
必要条件：有序数据集

三、排序算法全景解析

3.1 基础排序算法对比

算法	时间复杂度	空间复杂度	稳定性	适用场景
冒泡排序	O(n²)	O(1)	稳定	教学演示
选择排序	O(n²)	O(1)	不稳定	小规模数据
插入排序	O(n²)	O(1)	稳定	部分有序数据

3.2 高效排序算法实现

快速排序 - 分治思想典范

def quick_sort(lst):
    if len(lst) <= 1:
        return lst
    pivot = lst[0]
    left = [x for x in lst[1:] if x <= pivot]
    right = [x for x in lst[1:] if x > pivot]
    return quick_sort(left) + [pivot] + quick_sort(right)

归并排序 - 稳定高效选择

def merge(left, right):
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result += left[i:]
    result += right[j:]
    return result

def merge_sort(lst):
    if len(lst) <= 1:
        return lst
    mid = len(lst) // 2
    left = merge_sort(lst[:mid])
    right = merge_sort(lst[mid:])
    return merge(left, right)

3.3 线性排序算法

计数排序 - 限定范围整数排序

def counting_sort(lst, max_val=100):
    count = [0] * (max_val+1)
    for num in lst:
        count[num] += 1
    
    sorted_lst = []
    for i in range(len(count)):
        sorted_lst.extend([i] * count[i])
    return sorted_lst

基数排序 - 多关键字排序

def radix_sort(lst):
    max_num = max(lst)
    exp = 1
    while max_num // exp > 0:
        buckets = [[] for _ in range(10)]
        for num in lst:
            digit = (num // exp) % 10
            buckets[digit].append(num)
        lst = [num for bucket in buckets for num in bucket]
        exp *= 10
    return lst

四、高级数据结构与应用

4.1 堆与优先队列

import heapq

def heap_sort(lst):
    heapq.heapify(lst)
    return [heapq.heappop(lst) for _ in range(len(lst))]

4.2 递归经典：汉诺塔问题

def hanoi(n, source, auxiliary, target):
    if n > 0:
        # 将n-1个盘子从源柱移动到辅助柱
        hanoi(n-1, source, target, auxiliary)
        # 移动第n个盘子到目标柱
        print(f"移动盘子 {n} 从 {source} 到 {target}")
        # 将n-1个盘子从辅助柱移动到目标柱
        hanoi(n-1, auxiliary, source, target)

五、算法选择实战指南

5.1 排序算法选择矩阵

数据特征	推荐算法	原因
小规模数据(n<50)	插入排序	常数因子小
基本有序数据	冒泡排序	接近O(n)时间复杂度
大型随机数据	快速排序	平均O(n log n)性能
需要稳定排序	归并排序	稳定且高效
整数范围已知	计数排序	O(n+k)线性时间复杂度