一、LeetCode算法题分类与解题框架

LeetCode作为全球最主流的算法练习平台，其题目覆盖数据结构与算法的核心领域。根据题目特征可划分为六大类：

基础数据结构操作：链表翻转、二叉树遍历等
数组与字符串处理：双指针、滑动窗口技术
搜索与排序算法：二分查找、拓扑排序
动态规划专题：子序列问题、背包问题
图论应用：最短路径、连通分量
高级数据结构：并查集、线段树

建立系统化解题框架需把握三个核心原则：

问题抽象：将具体问题转化为数学模型（如将字符串匹配转化为状态机）
边界控制：特别注意空输入、单元素等特殊情况处理
复杂度优化：在正确性基础上追求时间/空间复杂度最优解

二、经典题型深度解析

2.1 链表操作：两数相加（Add Two Numbers）

问题描述：给定两个逆序存储的数字链表，计算它们的和并返回结果链表

解题思路：

初始化虚拟头节点简化边界处理
创建进位变量carry记录相加结果
遍历两个链表直至全部处理完毕
处理最终进位情况

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
def addTwoNumbers(l1: ListNode, l2: ListNode) -> ListNode:
    dummy = ListNode(0)
    current = dummy
    carry = 0
    while l1 or l2 or carry:
        val1 = l1.val if l1 else 0
        val2 = l2.val if l2 else 0
        total = val1 + val2 + carry
        carry = total // 10
        current.next = ListNode(total % 10)
        current = current.next
        if l1: l1 = l1.next
        if l2: l2 = l2.next
    return dummy.next

复杂度分析：时间复杂度O(max(m,n))，空间复杂度O(max(m,n))

2.2 滑动窗口：无重复字符的最长子串

问题描述：在字符串中找出不含重复字符的最长子串长度

解题技巧：

使用哈希集合记录窗口内字符
维护左右指针形成动态窗口
遇到重复字符时移动左指针

def lengthOfLongestSubstring(s: str) -> int:
    char_set = set()
    left = 0
    max_len = 0
    for right in range(len(s)):
        while s[right] in char_set:
            char_set.remove(s[left])
            left += 1
        char_set.add(s[right])
        max_len = max(max_len, right - left + 1)
    return max_len

优化方向：使用哈希表存储字符最后出现位置，可将时间复杂度优化至O(n)

2.3 二分查找：寻找两个正序数组的中位数

问题描述：在两个已排序数组中找到合并后的中位数，要求时间复杂度O(log(min(m,n)))

关键突破：

将问题转化为在两个数组中找第k小的数
每次比较两个数组的第k/2个元素
排除不可能包含中位数的部分数组

def findMedianSortedArrays(nums1, nums2):
    def findKth(a, b, k):
        if len(a) > len(b):
            a, b = b, a
        if not a:
            return b[k-1]
        if k == 1:
            return min(a[0], b[0])
        ia = min(k//2, len(a))
        ib = k - ia
        if a[ia-1] < b[ib-1]:
            return findKth(a[ia:], b, k-ia)
        else:
            return findKth(a, b[ib:], k-ib)
    m, n = len(nums1), len(nums2)
    total = m + n
    if total % 2 == 1:
        return findKth(nums1, nums2, total//2 + 1)
    else:
        left = findKth(nums1, nums2, total//2)
        right = findKth(nums1, nums2, total//2 + 1)
        return (left + right) / 2

三、进阶算法专题

3.1 动态规划：最长回文子串

状态定义：dp[i][j]表示s[i..j]是否为回文串

状态转移：

当s[i] == s[j]时：
- j-i <= 2：dp[i][j] = True
- 否则：dp[i][j] = dp[i+1][j-1]
当s[i] != s[j]时：dp[i][j] = False

def longestPalindrome(s: str) -> str:
    n = len(s)
    if n < 2:
        return s
    dp = [[False]*n for _ in range(n)]
    start, max_len = 0, 1
    for i in range(n):
        dp[i][i] = True
    for j in range(1, n):
        for i in range(j):
            if s[i] == s[j]:
                if j - i < 3:
                    dp[i][j] = True
                else:
                    dp[i][j] = dp[i+1][j-1]
                if dp[i][j] and j - i + 1 > max_len:
                    start = i
                    max_len = j - i + 1
    return s[start:start+max_len]

3.2 组合数学：带因子的二叉树

问题转化：将问题转化为完全背包问题的变种，使用动态规划统计组合数

解题步骤：

预处理数组，建立数值到索引的映射
初始化dp数组，dp[i]表示以arr[i]为根的树的数量
对于每个元素，寻找所有可能的因子对
使用记忆化搜索避免重复计算

def numFactoredBinaryTrees(arr):
    MOD = 10**9 + 7
    arr.sort()
    dp = {}
    index_map = {v: i for i, v in enumerate(arr)}
    for i in range(len(arr)):
        dp[arr[i]] = 1
    for i in range(len(arr)):
        for j in range(i):
            if arr[i] % arr[j] == 0:
                factor = arr[i] // arr[j]
                if factor in index_map:
                    dp[arr[i]] = (dp[arr[i]] + dp[arr[j]] * dp[factor]) % MOD
    return sum(dp.values()) % MOD

四、高效刷题策略

五遍刷题法：
- 第一遍：独立解题，记录卡壳点
- 第二遍：参考最优解，理解设计思路
- 第三遍：默写代码，注意边界条件
- 第四遍：变换输入规模，验证鲁棒性
- 第五遍：总结通用模式，形成方法论
错题管理系统：
- 建立分类标签（数据结构/算法/边界条件）
- 记录错误类型（逻辑错误/语法错误/超时）
- 定期复习，确保掌握度达到90%以上
模拟面试训练：
- 使用LeetCode的面试模式进行限时训练
- 练习口头阐述解题思路
- 培养代码可读性与注释习惯

通过系统化的训练方法，配合对经典算法题的深度理解，开发者可以在3-6个月内显著提升算法能力。建议每天保持2-3道中等难度题目的练习量，重点突破动态规划、图论等高阶专题，为技术面试和实际工程问题解决奠定坚实基础。

从零突破：LeetCode算法题全解析与实战指南