LeetCode面试经典150题解析与工程实践

1. 项目背景与核心价值

最近在整理LeetCode面试经典150题时，发现很多题目虽然解法简单，但背后的算法思想和工程应用价值往往被忽视。这个系列记录了我每天刷题时的思考过程，特别是3月9日这天的解题笔记，重点不是给出标准答案，而是分享如何从面试官角度分析问题。

在真实的面试场景中，面试官期待的往往不是最优解，而是你拆解问题的思路。比如遇到「两数之和」这种基础题时，能否主动分析暴力解法、哈希表解法在不同场景下的trade-off，比直接写出完美代码更重要。这个系列就是基于这样的视角，把每个题目当作真实的系统设计问题来处理。

2. 题目解析方法论

2.1 问题拆解四步法

对于任何算法题，我习惯用以下框架分析：

1. 问题转化：将题目描述转化为正式的逻辑命题
2. 边界确认：明确输入输出的合法范围
3. 复杂度预估：根据数据规模反推可接受的算法复杂度
4. 解法演进：从暴力解法开始逐步优化

以「盛最多水的容器」为例：

• 转化：寻找max(min(height[i], height[j]) * (j - i))
• 边界：n>=2，height[i]>=0
• 复杂度：n=1e5要求O(n)或O(nlogn)
• 演进：暴力O(n²)→双指针O(n)

2.2 代码实现技巧

python复制def maxArea(height):
    l, r = 0, len(height)-1
    res = 0
    while l < r:
        res = max(res, min(height[l], height[r]) * (r - l))
        if height[l] < height[r]:
            l += 1
        else:
            r -= 1
    return res

关键点在于理解为什么移动较矮的指针是正确的——因为容器的盛水量由短板决定，移动长板不可能获得更大容量。

3. 典型题目深度剖析

3.1 接雨水问题

这是动态规划和双指针结合的经典案例。我推荐先掌握暴力解法，再优化到O(n)：

1. 暴力解法：对每个位置i，找左右最高柱子

python复制def trap(height):
    res = 0
    for i in range(1, len(height)-1):
        left_max = max(height[:i])
        right_max = max(height[i+1:])
        res += max(0, min(left_max, right_max) - height[i])
    return res  # O(n²)时间复杂度

2. 动态规划优化：预处理左右最大值数组

python复制def trap(height):
    n = len(height)
    left_max = [0]*n
    right_max = [0]*n
    left_max[0] = height[0]
    for i in range(1, n):
        left_max[i] = max(left_max[i-1], height[i])
    right_max[-1] = height[-1]
    for i in range(n-2, -1, -1):
        right_max[i] = max(right_max[i+1], height[i])
    return sum(min(left_max[i], right_max[i]) - height[i] for i in range(n))  # O(n)空间

3. 双指针终极优化：空间复杂度O(1)

python复制def trap(height):
    l, r = 0, len(height)-1
    left_max = right_max = res = 0
    while l < r:
        if height[l] < height[r]:
            left_max = max(left_max, height[l])
            res += left_max - height[l]
            l += 1
        else:
            right_max = max(right_max, height[r])
            res += right_max - height[r]
            r -= 1
    return res

3.2 滑动窗口最大值

这道题考察对单调队列的理解，实际工程中常用于实时数据流分析：

python复制from collections import deque

def maxSlidingWindow(nums, k):
    q = deque()
    res = []
    for i, num in enumerate(nums):
        while q and nums[q[-1]] <= num:
            q.pop()
        q.append(i)
        if q[0] == i - k:
            q.popleft()
        if i >= k - 1:
            res.append(nums[q[0]])
    return res

关键点：

1. 队列中存储的是索引而非值
2. 维护单调递减队列
3. 及时移除过期元素

4. 面试实战技巧

4.1 白板编码注意事项

1. 先写函数签名和示例
2. 用注释标注算法步骤
3. 主动讨论边界条件
4. 完成后人工走查测试用例

4.2 复杂度分析话术模板

"这个算法的时间复杂度是O(n)，因为每个元素最多被处理两次。空间复杂度是O(k)，因为队列中最多存储k个元素。在实际工程中，当n>1e6时可能需要考虑..."

4.3 常见follow-up问题

1. 如何处理数据流场景？
2. 如果内存有限怎么办？
3. 如何扩展到分布式环境？

5. 刷题路线建议

5.1 分类训练计划

5.2 每日训练节奏

1. 早间：2道新题（60分钟）
2. 午后：复习旧题（30分钟）
3. 晚间：模拟面试（45分钟）

6. 工程实践延伸

很多算法题其实源自真实工程问题：

• 接雨水 → 分布式系统限流算法
• 滑动窗口最大值 → 实时监控系统
• LRU缓存 → 数据库查询优化

建议在理解算法后，主动思考其工程应用场景。比如实现一个简单的RateLimiter：

python复制class RateLimiter:
    def __init__(self, n, t):
        self.requests = deque()
        self.n = n  # 最大请求数
        self.t = t  # 时间窗口(秒)

    def allow(self):
        now = time.time()
        while self.requests and self.requests[0] <= now - self.t:
            self.requests.popleft()
        if len(self.requests) < self.n:
            self.requests.append(now)
            return True
        return False

这种从算法到工程的思维转换，往往能在面试中制造亮点。当面试官问"这个算法能用在什么地方"时，能给出具体场景的候选人通常会更受青睐。