以下是五大核心算法的重点解析和LeetCode经典题解，包含最优解法和模板代码：
一、数组操作（双指针/滑动窗口）
核心思想：通过索引指针高效遍历与操作数组
1. 移动零（No.283）
def moveZeroes(nums):slow = 0for fast in range(len(nums)):if nums[fast] != 0:nums[slow], nums[fast] = nums[fast], nums[slow]slow += 12. 盛最多水的容器（No.11）
def maxArea(height):left, right = 0, len(height)-1max_area = 0while left < right:area = min(height[left], height[right]) * (right - left)max_area = max(max_area, area)if height[left] < height[right]:left += 1else:right -= 1return max_area3. 最小覆盖子串（No.76）滑动窗口模板
def minWindow(s, t):from collections import Counterneed = Counter(t)missing = len(t)left = start = end = 0for right, char in enumerate(s, 1):if need[char] > 0:missing -= 1need[char] -= 1if missing == 0: # 窗口满足条件# 收缩左边界while left < right and need[s[left]] < 0:need[s[left]] += 1left += 1# 更新结果if not end or right-left <= end-start:start, end = left, right# 移动左边界need[s[left]] += 1missing += 1left += 1return s[start:end]二、哈希表应用（快速查找）
核心思想：空间换时间，实现O(1)查找
1. 两数之和（No.1）
def twoSum(nums, target):seen = {}for i, num in enumerate(nums):if target - num in seen:return [seen[target-num], i]seen[num] = ireturn []2. 字母异位词分组（No.49）
def groupAnagrams(strs):from collections import defaultdictd = defaultdict(list)for s in strs:key = ''.join(sorted(s))d[key].append(s)return list(d.values())3. 最长连续序列（No.128）
def longestConsecutive(nums):num_set = set(nums)max_len = 0for num in num_set:# 确保从序列起点开始if num-1 not in num_set:curr = numcurr_len = 1while curr+1 in num_set:curr += 1curr_len += 1max_len = max(max_len, curr_len)return max_len三、树形结构（递归/迭代）
核心思想：分治思想处理子树，栈/队列辅助迭代
1. 二叉树的最大深度（No.104）
# 递归
def maxDepth(root):if not root: return 0return 1 + max(maxDepth(root.left), maxDepth(root.right))# 迭代（BFS）
from collections import deque
def maxDepth(root):if not root: return 0queue = deque([root])depth = 0while queue:depth += 1for _ in range(len(queue)):node = queue.popleft()if node.left: queue.append(node.left)if node.right: queue.append(node.right)return depth2. 验证二叉搜索树（No.98）
def isValidBST(root):def valid(node, low=-float('inf'), high=float('inf')):if not node: return Trueif node.val <= low or node.val >= high:return Falsereturn (valid(node.left, low, node.val) and valid(node.right, node.val, high))return valid(root)3. 二叉树的最近公共祖先（No.236）
def lowestCommonAncestor(root, p, q):if not root or root == p or root == q:return rootleft = lowestCommonAncestor(root.left, p, q)right = lowestCommonAncestor(root.right, p, q)if left and right: return rootreturn left if left else right四、排序算法（归并/快排）
核心思想：分治策略实现高效排序
1. 快速排序模板
def quick_sort(arr, l, r):if l >= r: return# 分区操作pivot = partition(arr, l, r)quick_sort(arr, l, pivot-1)quick_sort(arr, pivot+1, r)def partition(arr, l, r):import random# 随机选择基准避免最坏情况rand_idx = random.randint(l, r)arr[rand_idx], arr[r] = arr[r], arr[rand_idx]pivot_val = arr[r]i = lfor j in range(l, r):if arr[j] < pivot_val:arr[i], arr[j] = arr[j], arr[i]i += 1arr[i], arr[r] = arr[r], arr[i]return i2. 合并区间（No.56）
def merge(intervals):intervals.sort(key=lambda x: x[0])merged = []for interval in intervals:if not merged or merged[-1][1] < interval[0]:merged.append(interval)else:merged[-1][1] = max(merged[-1][1], interval[1])return merged3. 数组中的第K个最大元素（No.215）
def findKthLargest(nums, k):import heapqmin_heap = []for num in nums:heapq.heappush(min_heap, num)if len(min_heap) > k:heapq.heappop(min_heap)return min_heap[0]五、动态规划（状态转移）
核心思想：定义状态与状态转移方程，避免重复计算
1. 爬楼梯（No.70）基础模板
def climbStairs(n):if n <= 2: return ndp = [0]*(n+1)dp[1], dp[2] = 1, 2for i in range(3, n+1):dp[i] = dp[i-1] + dp[i-2]return dp[n]2. 最长递增子序列（No.300）
# 标准DP解法 O(n²)
def lengthOfLIS(nums):dp = [1]*len(nums)for i in range(1, len(nums)):for j in range(i):if nums[i] > nums[j]:dp[i] = max(dp[i], dp[j]+1)return max(dp)# 贪心+二分 O(nlogn)
def lengthOfLIS(nums):tails = [] # 存储最小尾部元素for num in nums:# 二分查找插入位置l, r = 0, len(tails)while l < r:mid = (l+r)//2if tails[mid] < num:l = mid+1else:r = midif l == len(tails):tails.append(num)else:tails[l] = numreturn len(tails)3. 编辑距离（No.72）经典二维DP
def minDistance(word1, word2):m, n = len(word1), len(word2)dp = [[0]*(n+1) for _ in range(m+1)]# 初始化边界for i in range(1, m+1): dp[i][0] = ifor j in range(1, n+1): dp[0][j] = jfor i in range(1, m+1):for j in range(1, n+1):if word1[i-1] == word2[j-1]:dp[i][j] = dp[i-1][j-1]else:dp[i][j] = 1 + min(dp[i-1][j], # 删除dp[i][j-1], # 插入dp[i-1][j-1] # 替换)return dp[m][n]六、综合训练题库（按难度排序）
| 类别 | 基础题（掌握模板） | 进阶题（应用变形） | 挑战题（综合优化） |
|---|---|---|---|
| 数组 | 26/27/283/167 | 11/15/16/238 | 42/128/239/295 |
| 哈希表 | 1/202/242 | 49/560/763 | 30/76/146/460 |
| 树 | 100/101/104/226 | 102/105/236 | 124/297/337 |
| 排序 | 75/88/147 | 148/179/215 | 56/164/315 |
| DP | 70/118/121 | 62/64/139/198 | 72/152/312/322 |
高效训练建议：
每日专项训练：每天专注1个算法类型（如周一数组/周二哈希表）
三遍刷题法：
第一遍：独立解题（30分钟）
第二遍：学习最优解并复现
第三遍：隔周重做+总结模板
重点突破：
双指针（数组/字符串）
回溯法（树形问题）
状态机（动态规划）
堆应用（排序/TOP K问题）
核心技巧：
数组：左右指针/快慢指针/前缀和
哈希表：空间换时间/计数器
树：递归三要素（终止条件/本级任务/返回值）
排序：归并分治/快速选择
DP：状态定义 → 转移方程 → 初始化 → 遍历顺序
)
