算法与数据结构 on PlumePHP

01. 算法复杂度分析

Wed, 05 Aug 2026 00:00:00 +0000

1. 为什么需要复杂度分析

算法复杂度分析是衡量算法效率的标准方法，它不依赖具体的机器环境，而是从问题规模增长的角度评估性能。

同一套代码在 i3 和 i9 上运行时间不同，但它们的增长趋势是一致的。

02. 数组、链表与线性表

Wed, 05 Aug 2026 00:00:00 +0000

1. 数组（Array）

1.1 内存布局

数组是连续内存存储的线性结构，通过基地址 + 偏移量直接计算元素位置。

索引: 0 1 2 3 4
内存: [A0] [A1] [A2] [A3] [A4]
 ↑ 基地址
 A[i] 地址 = 基地址 + i × 元素大小

1.2 时间复杂度分析

操作	时间	说明
随机访问	O(1)	直接计算地址
尾部插入	O(1)/O(n)	有空间时 O(1)，扩容时 O(n)
中间插入	O(n)	需要移动后续元素
删除	O(n)	需要移动后续元素
查找	O(n)	无序数组遍历；有序数组可二分 O(log n)

class DynamicArray:
 """动态数组实现（类似 Python list / Java ArrayList）"""
 def __init__(self):
 self._capacity = 4
 self._size = 0
 self._data = [None] * self._capacity

 def append(self, val):
 if self._size == self._capacity:
 self._resize(self._capacity * 2)
 self._data[self._size] = val
 self._size += 1

 def _resize(self, new_cap):
 new_data = [None] * new_cap
 for i in range(self._size):
 new_data[i] = self._data[i]
 self._data = new_data
 self._capacity = new_cap

 def insert(self, index, val):
 if self._size == self._capacity:
 self._resize(self._capacity * 2)
 for i in range(self._size, index, -1):
 self._data[i] = self._data[i - 1]
 self._data[index] = val
 self._size += 1

 def delete(self, index):
 for i in range(index, self._size - 1):
 self._data[i] = self._data[i + 1]
 self._size -= 1
 # 缩容：size < capacity/4 时减半
 if self._size < self._capacity // 4 and self._capacity > 4:
 self._resize(self._capacity // 2)

均摊分析：动态数组扩容是 O(n)，但 n 次插入总时间是 O(n)，所以单次均摊 O(1)。

03. 树与二叉树

Wed, 05 Aug 2026 00:00:00 +0000

1. 树的基本概念

1.1 术语定义

 A ← 根节点（Root）
 /|\
 B C D ← B、C、D 是 A 的子节点
 /| |
 E F G ← 叶子节点（无子节点）

A 的深度：0（层数从 0 开始）
树的度：3（最大子节点数）
高度：3（最深路径的节点数）

术语	定义
度	节点拥有的子节点数
深度	根到该节点的边数
高度	该节点到最远叶子的边数
满二叉树	每层节点数达到最大值
完全二叉树	除最后一层外满，最后一层左对齐

2. 二叉树遍历

2.1 四种遍历方式

class TreeNode:
 def __init__(self, val=0):
 self.val = val
 self.left = None
 self.right = None

# 前序遍历：根 → 左 → 右
def pre_order(root):
 if not root:
 return
 print(root.val, end=' ')
 pre_order(root.left)
 pre_order(root.right)

# 中序遍历：左 → 根 → 右（BST 中得到有序序列）
def in_order(root):
 if not root:
 return
 in_order(root.left)
 print(root.val, end=' ')
 in_order(root.right)

# 后序遍历：左 → 右 → 根
def post_order(root):
 if not root:
 return
 post_order(root.left)
 post_order(root.right)
 print(root.val, end=' ')

# 层序遍历（BFS）
def level_order(root):
 if not root:
 return
 from collections import deque
 q = deque([root])
 while q:
 node = q.popleft()
 print(node.val, end=' ')
 if node.left:
 q.append(node.left)
 if node.right:
 q.append(node.right)

2.2 迭代实现

# 非递归中序遍历（栈）
def in_order_iter(root):
 stack = []
 result = []
 curr = root
 while curr or stack:
 while curr:
 stack.append(curr)
 curr = curr.left
 curr = stack.pop()
 result.append(curr.val)
 curr = curr.right
 return result

3. 二叉搜索树（BST）

3.1 定义

左子树所有节点 < 根 < 右子树所有节点。

04. 图算法

Wed, 05 Aug 2026 00:00:00 +0000

1. 图的表示

1.1 邻接矩阵

适合稠密图（边数接近 n²），支持 O(1) 判边。

# n 个节点的图
n = 5
# 有权图：matrix[i][j] = 边权，无边 = inf
inf = float('inf')
adj_matrix = [[inf] * n for _ in range(n)]
for i in range(n):
 adj_matrix[i][i] = 0

# 添加边
adj_matrix[0][1] = 4
adj_matrix[1][2] = 1

1.2 邻接表

适合稀疏图（边数远小于 n²），空间 O(V + E)。

05. 排序算法

Wed, 05 Aug 2026 00:00:00 +0000

1. 排序算法概览

算法	平均时间	最坏时间	空间	稳定	适用场景
冒泡排序	O(n²)	O(n²)	O(1)	✅	教学/极小数据
选择排序	O(n²)	O(n²)	O(1)	❌	极小数据
插入排序	O(n²)	O(n²)	O(1)	✅	几乎有序的数据
希尔排序	O(n^1.3)	O(n²)	O(1)	❌	中等规模
归并排序	O(n log n)	O(n log n)	O(n)	✅	链表排序、外部排序
快速排序	O(n log n)	O(n²)	O(log n)	❌	通用场景首选
堆排序	O(n log n)	O(n log n)	O(1)	❌	内存敏感、Top-K
计数排序	O(n + k)	O(n + k)	O(k)	✅	整数范围小
桶排序	O(n + k)	O(n²)	O(n + k)	✅	均匀分布数据
基数排序	O(d(n + k))	O(d(n + k))	O(n + k)	✅	固定位数整数

2. 简单排序 O(n²)

2.1 冒泡排序

def bubble_sort(arr):
 n = len(arr)
 for i in range(n):
 swapped = False
 for j in range(n - 1 - i):
 if arr[j] > arr[j + 1]:
 arr[j], arr[j + 1] = arr[j + 1], arr[j]
 swapped = True
 if not swapped:
 break
 return arr

2.2 插入排序

def insert_sort(arr):
 """
 摸牌式插入，维护已排序前缀
 几乎有序时接近 O(n)
 """
 for i in range(1, len(arr)):
 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

Python 的 list.sort() 在数据量小时使用插入排序，大数据用 Timsort（归并+插入的混合）。

06. 搜索与哈希

Wed, 05 Aug 2026 00:00:00 +0000

1. 二分查找（Binary Search）

1.1 基本思想

在已排序数组中，每次将搜索范围减半。

def binary_search(arr, target):
 """
 返回 target 的索引，不存在返回 -1
 循环不变量：target 在 [left, right] 范围内
 """
 left, right = 0, len(arr) - 1
 while left <= right:
 mid = left + (right - left) // 2 # 防溢出
 if arr[mid] == target:
 return mid
 elif arr[mid] < target:
 left = mid + 1
 else:
 right = mid - 1
 return -1

# 找左边界（第一个 ≥ target 的位置）
def lower_bound(arr, target):
 left, right = 0, len(arr)
 while left < right:
 mid = left + (right - left) // 2
 if arr[mid] < target:
 left = mid + 1
 else:
 right = mid
 return left

# 找右边界（第一个 > target 的位置）
def upper_bound(arr, target):
 left, right = 0, len(arr)
 while left < right:
 mid = left + (right - left) // 2
 if arr[mid] <= target:
 left = mid + 1
 else:
 right = mid
 return left

1.2 二分查找的扩展应用

# 旋转排序数组中找最小值
def find_min_rotated(arr):
 left, right = 0, len(arr) - 1
 while left < right:
 mid = left + (right - left) // 2
 if arr[mid] > arr[right]:
 left = mid + 1
 else:
 right = mid
 return arr[left]

# 在旋转数组中搜索
def search_rotated(arr, target):
 left, right = 0, len(arr) - 1
 while left <= right:
 mid = left + (right - left) // 2
 if arr[mid] == target:
 return mid
 # 判断哪一半有序
 if arr[left] <= arr[mid]: # 左半有序
 if arr[left] <= target < arr[mid]:
 right = mid - 1
 else:
 left = mid + 1
 else: # 右半有序
 if arr[mid] < target <= arr[right]:
 left = mid + 1
 else:
 right = mid - 1
 return -1

二分查找的精髓：不是只用于查找，而是用于求解单调性问题的最优解（如能力值验证）。

07. 动态规划

Wed, 05 Aug 2026 00:00:00 +0000

1. 动态规划的核心思想

1.1 DP 的本质

最优子结构：问题的最优解包含子问题的最优解。
重叠子问题：递归解法中会反复求解相同的子问题。
状态转移：用已解决的子问题推导更大问题的解。

08. 贪心与回溯

Wed, 05 Aug 2026 00:00:00 +0000

1. 贪心算法（Greedy）

1.1 核心思想

每一步都做出在当前看来最优的选择，希望最终结果也是全局最优。

两个关键性质：

贪心选择性质：局部最优能导向全局最优
最优子结构性质：问题的最优解包含子问题的最优解

1.2 经典问题：活动选择

def activity_selection(activities):
 """
 给定活动开始和结束时间，选择最多不冲突的活动
 贪心策略：每次选结束时间最早的活动
 """
 # 按结束时间排序
 activities.sort(key=lambda x: x[1])
 selected = [activities[0]]
 last_end = activities[0][1]

 for i in range(1, len(activities)):
 if activities[i][0] >= last_end: # 开始时间 ≥ 上一个结束时间
 selected.append(activities[i])
 last_end = activities[i][1]

 return selected

# 示例：活动 = [(开始, 结束), ...]
activities = [(1, 4), (3, 5), (0, 6), (5, 7), (3, 8), (5, 9), (6, 10)]
print(activity_selection(activities))

1.3 经典问题：分数背包

def fractional_knapsack(weights, values, capacity):
 """
 物品可以分割，贪心策略：按单位价值从高到低选取
 注意：此策略对 0-1 背包不成立！
 """
 items = [(values[i] / weights[i], weights[i], values[i])
 for i in range(len(weights))]
 items.sort(reverse=True) # 按单位价值降序

 total_value = 0.0
 for ratio, w, v in items:
 if capacity >= w:
 total_value += v
 capacity -= w
 else:
 total_value += capacity * ratio
 break
 return total_value

1.4 经典问题：最小生成树（Prim/Kruskal）

# 见前文图算法中的 Prim 和 Kruskal 实现
# 它们都是基于贪心策略：
# - Prim：每次选连接已选集合和未选集合的最短边
# - Kruskal：每次选全局最短且不形成环的边

1.5 经典问题：哈夫曼编码

import heapq

def huffman_coding(freq):
 """
 贪心策略：每次合并频率最小的两棵树
 用于数据压缩（如 ZIP）
 """
 heap = [[w, [s, ""]] for s, w in freq.items()]
 heapq.heapify(heap)

 while len(heap) > 1:
 lo = heapq.heappop(heap)
 hi = heapq.heappop(heap)
 # 左路标 0，右路标 1
 for pair in lo[1:]:
 pair[1] = '0' + pair[1]
 for pair in hi[1:]:
 pair[1] = '1' + pair[1]
 heapq.heappush(heap, [lo[0] + hi[0]] + lo[1:] + hi[1:])

 return sorted(heapq.heappop(heap)[1:], key=lambda p: (len(p[-1]), p))

# 示例
freq = {'a': 45, 'b': 13, 'c': 12, 'd': 16, 'e': 9, 'f': 5}
codes = huffman_coding(freq)
for char, code in codes:
 print(f"{char}: {code}")

2. 回溯法（Backtracking）

2.1 核心框架

回溯 = DFS + 剪枝

通用模板：
function backtrack(路径, 选择列表):
 if 满足结束条件:
 添加结果
 return
 for 选择 in 选择列表:
 做选择
 backtrack(路径, 新选择列表)
 撤销选择（恢复现场）

2.2 全排列

def permute(nums):
 """所有不重复排列"""
 n = len(nums)
 result = []

 def backtrack(path, used):
 if len(path) == n:
 result.append(path[:])
 return
 for i in range(n):
 if used[i]:
 continue
 # if i > 0 and nums[i] == nums[i-1] and not used[i-1]: # 去重
 # continue
 used[i] = True
 path.append(nums[i])
 backtrack(path, used)
 path.pop()
 used[i] = False

 backtrack([], [False] * n)
 return result

2.3 N 皇后问题

def solve_n_queens(n):
 """
 每行放一个皇后，列和对角线不能冲突
 """
 result = []
 board = [['.'] * n for _ in range(n)]

 def is_valid(row, col):
 # 检查列
 for i in range(row):
 if board[i][col] == 'Q':
 return False
 # 检查左上对角线
 for i, j in zip(range(row - 1, -1, -1), range(col - 1, -1, -1)):
 if board[i][j] == 'Q':
 return False
 # 检查右上对角线
 for i, j in zip(range(row - 1, -1, -1), range(col + 1, n)):
 if board[i][j] == 'Q':
 return False
 return True

 def backtrack(row):
 if row == n:
 result.append([''.join(r) for r in board])
 return
 for col in range(n):
 if not is_valid(row, col):
 continue
 board[row][col] = 'Q'
 backtrack(row + 1)
 board[row][col] = '.'

 backtrack(0)
 return result

2.4 子集求和

def subset_sum(nums, target):
 """
 找出所有和为 target 的子集（元素不重复使用）
 """
 nums.sort()
 result = []

 def backtrack(start, path, curr_sum):
 if curr_sum == target:
 result.append(path[:])
 return
 if curr_sum > target:
 return # 剪枝：和已超过目标
 for i in range(start, len(nums)):
 if i > start and nums[i] == nums[i - 1]:
 continue # 去重
 if curr_sum + nums[i] > target:
 break # 剪枝：后续元素更大
 path.append(nums[i])
 backtrack(i + 1, path, curr_sum + nums[i])
 path.pop()

 backtrack(0, [], 0)
 return result

3. 剪枝策略

3.1 常用剪枝技巧

剪枝类型	说明	示例
和/积超界	当前状态不可能达到目标	子集和超出 target
重复状态	相同状态不再重复搜索	排序后跳过相同元素
对称性	利用对称减少搜索	图染色只考虑不同排列
下界估计	估计剩余最小值，仍不够则剪	分支限界

3.2 分支限界（Branch and Bound）

import heapq

def branch_bound_knapsack(weights, values, capacity):
 """
 0-1 背包的分支限界解法
 用优先队列（最大堆）按上界排序
 """
 n = len(weights)
 items = sorted(range(n), key=lambda i: values[i] / weights[i], reverse=True)

 # 计算上界：当前价值 + 贪心填充剩余容量
 def bound(idx, curr_w, curr_v):
 if curr_w >= capacity:
 return 0
 remaining = capacity - curr_w
 upper = curr_v
 for i in range(idx, n):
 j = items[i]
 if weights[j] <= remaining:
 upper += values[j]
 remaining -= weights[j]
 else:
 upper += remaining * values[j] / weights[j]
 break
 return upper

 max_value = 0
 # (-上界, 当前索引, 当前重量, 当前价值)
 pq = [(-bound(0, 0, 0), 0, 0, 0)]

 while pq:
 neg_bound, idx, curr_w, curr_v = heapq.heappop(pq)

 if idx == n:
 max_value = max(max_value, curr_v)
 continue

 # 不选当前物品
 b = bound(idx + 1, curr_w, curr_v)
 if b > max_value:
 heapq.heappush(pq, (-b, idx + 1, curr_w, curr_v))

 # 选当前物品
 j = items[idx]
 if curr_w + weights[j] <= capacity:
 new_v = curr_v + values[j]
 b = bound(idx + 1, curr_w + weights[j], new_v)
 if b > max_value:
 heapq.heappush(pq, (-b, idx + 1, curr_w + weights[j], new_v))

 return max_value

4. 贪心 vs 回溯决策树

贪心：
 当前选择 → 子问题 → 最优解（不回头）
 ↓
 可能不是全局最优（需证明）

回溯：
 当前选择 → 子问题 → 所有可能解
 ↓
 剪枝排除不可能分支
 ↓
 找到最优或所有解（穷举搜索）

5. 总结

算法	时间复杂度	空间复杂度	是否保证最优
贪心	O(n log n) ~ O(n)	O(1) ~ O(n)	不一定
回溯	指数级（O(2ⁿ) 或 O(n!)）	O(n) 递归栈	✅（搜索全部解空间）
分支限界	最坏指数级，实际剪枝后好很多	O(待展开节点数)	✅

实战建议：先尝试贪心（因为快），如果不能证明最优性，再用回溯/动态规划。