java-python-code-reviewer

Java 和 Python 代码审查

何时使用此 Skill

在以下情况下使用此 Skill：

• 审查 LeetCode 问题解答
• 检查代码的正确性和效率
• 比较 Java 和 Python 实现
• 针对算法实现提供反馈
• 优化现有解法

审查框架

1. 正确性分析

检查以下内容：

• 边界情况处理（空输入、null、单个元素）
• 边界条件（数组索引、循环终止）
• 算法实现中的逻辑错误
• 测试用例覆盖范围（基本、边界和特殊情况）

常见边界情况：

• 空数组/字符串：[]、""
• null 输入：null、None
• 单个元素：[1]、"a"
• 重复元素：[1,1,1]
• 负数：[-1, -5]
• 大输入：测试时间/空间限制

2. 时间和空间复杂度

分析并验证：

• 时间复杂度：根据输入规模统计操作次数
• 空间复杂度：统计使用的辅助空间
• 与最优解法进行比较

提供：

Current: O(n²) time, O(1) space
Optimal: O(n) time, O(n) space using HashMap
Trade-off: Use extra space for better time complexity

复杂度参考：

• O(1)：直接访问
• O(log n)：二分查找、平衡树
• O(n)：单次遍历、线性扫描
• O(n log n)：高效排序、分治
• O(n²)：嵌套循环
• O(2ⁿ)：指数级（回溯、暴力法）

3. 代码质量——Java

Java 最佳实践：

• 使用合适的数据结构（ArrayList、HashMap、HashSet）
• 遵循命名规范（方法/变量使用 camelCase）
• 处理 null 检查和验证
• 正确使用泛型（使用 List<Integer>，而非原始类型）
• 优先使用接口而非实现类（使用 List<>，而非 ArrayList<>）

需要指出的 Java 反模式：

// Bad: Raw types
ArrayList list = new ArrayList();

// Good: Generics
List<Integer> list = new ArrayList<>();

// Bad: Manual array copying
for (int i = 0; i < arr.length; i++) { ... }

// Good: Built-in methods
Arrays.copyOf(arr, arr.length);

// Bad: String concatenation in loop
String s = "";
for (String str : list) { s += str; }

// Good: StringBuilder
StringBuilder sb = new StringBuilder();
for (String str : list) { sb.append(str); }

检查以下内容：

• 整数溢出：必要时建议使用 long
• 是否正确处理异常
• 内存泄漏（未关闭的资源）
• 适用时检查线程安全

4. 代码质量——Python

Python 最佳实践：

• 使用 Pythonic 习惯用法（列表推导式、enumerate、zip）
• 遵循 PEP 8 风格指南
• 使用合适的数据结构（set、dict、deque）
• 利用内置函数

需要指出的 Python 反模式：

# Bad: Manual index tracking
for i in range(len(arr)):
    print(i, arr[i])

# Good: enumerate
for i, val in enumerate(arr):
    print(i, val)

# Bad: Building list with append in loop
result = []
for x in arr:
    result.append(x * 2)

# Good: List comprehension
result = [x * 2 for x in arr]

# Bad: Multiple membership checks
if x == 'a' or x == 'b' or x == 'c':

# Good: Use set or tuple
if x in {'a', 'b', 'c'}:

检查以下内容：

• 是否使用合适的集合（collections.defaultdict、Counter）
• 是否使用生成器表达式提高内存效率
• 是否正确检查 None
• 是否使用类型提示以提高代码清晰度（可选，但有帮助）

5. 算法优化

建议改进以下情况：

• 不必要的嵌套循环 → 使用 HashMap，将复杂度降至 O(n)
• 重复计算 → 使用记忆化/动态规划
• 冗余排序 → 使用堆或快速选择
• 多次遍历 → 合并为单次遍历
• 额外空间占用 → 原地修改

模式识别：

• Two Sum 模式 → 使用 HashMap
• 滑动窗口 → 双指针
• 子数组和 → 前缀和
• 最长子字符串 → 滑动窗口 + HashMap
• 树遍历 → 使用合适的数据结构进行 DFS/BFS

6. 比较：Java 与 Python

比较实现时：

Java 的优势：

• 显式类型可及早发现错误
• 更适合对性能要求较高的代码
• 数据结构的使用更加清晰

Python 的优势：

• 更简洁易读
• 标准库丰富（collections、itertools）
• 更适合快速原型开发

指出以下不一致之处：

• 使用了不同的算法（应采用相同思路）
• 时间/空间复杂度不同
• 其中一个版本缺少边界情况处理

7. 审查输出格式

按以下结构组织审查：

## Correctness: ✓ Pass / ⚠ Issues Found

[List any correctness issues]

## Complexity Analysis

- Time: O(?) - [Explain]
- Space: O(?) - [Explain]
- Optimal: [If current solution is not optimal]

## Code Quality

**Strengths:**
- [List positive aspects]

**Issues:**
- [Issue 1] at line X: [Explanation]
- [Issue 2] at line Y: [Explanation]

**Suggestions:**
- [Suggestion 1]: [Why it's better]
- [Suggestion 2]: [Why it's better]

## Overall Assessment

[Summary and recommendation]

审查清单

完成审查前：

• 使用边界情况进行测试
• 验证时间复杂度
• 验证空间复杂度
• 检查常见错误
• 与最优解法进行比较
• 提出具体的改进建议
• 为建议提供代码示例

审查示例

示例 1：Two Sum

// Code under review
public int[] twoSum(int[] nums, int target) {
    for (int i = 0; i < nums.length; i++) {
        for (int j = i + 1; j < nums.length; j++) {
            if (nums[i] + nums[j] == target) {
                return new int[]{i, j};
            }
        }
    }
    return new int[]{};
}

审查意见：

• 正确性：✓ 运行正确
• 时间复杂度：O(n²)——可优化至 O(n)
• 建议：使用 HashMap 存储已遍历的数字及其索引

优化后：

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement)) {
            return new int[]{map.get(complement), i};
        }
        map.put(nums[i], i);
    }
    return new int[]{};
}

项目背景

• 查看 leetcode_java/ 和 leetcode_python/ 中的解法
• 对比不同语言的实现
• 对照 algorithm/ 和 data_structure/ 中的模式
• 参考 doc/ 中的复杂度图表进行分析