1
class Solution:
2
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
3
        # 1. 终止条件：遇到空节点，或找到 p / q
4
        if not root or root == p or root == q:
5
            return root
6

7
        # 2. 递归遍历左右子树
8
        left = self.lowestCommonAncestor(root.left, p, q)
9
        right = self.lowestCommonAncestor(root.right, p, q)
10

11
        # 3. 自底向上处理结果
12
        if left and right:
13
            return root
14
        return left or right

1
class Solution:
2
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
3
        # 1. 确保 p 的值小于 q 的值，简化后续的区间判断
4
        if p.val > q.val:
5
            p, q = q, p
6

7
        # 2. 从根节点开始迭代遍历
8
        while root:
9
            # 3. 根据 BST 性质进行分支判断
10
            if root.val > q.val:      # 目标都在左侧
11
                root = root.left
12
            elif root.val < p.val:    # 目标都在右侧
13
                root = root.right
14
            else:                      # 当前节点就是分界点(LCA)
15
                return root
16

17
        return None

1
nums = [1, 2, 3]
2
nums[1:]   # → [2, 3]   去掉第一个，剩余所有
3
nums[:2]   # → [1, 2]   前两个

1
perms = [[2,3], [3,2]]
2
for p in perms:
3
    print(p)
4
# 第1次：p = [2, 3]
5
# 第2次：p = [3, 2]

1
p = [2, 3]          # 长度为 2
2
range(len(p) + 1)   # → 0, 1, 2   共 3 个位置 所以要len(p)+1

1
# 不 copy 的错误情况：
2
p = [2, 3]
3
p.insert(0, 1)   # p → [1, 2, 3]  ← p 被改了！
4
p.insert(1, 1)   # 在 [1,2,3] 上插 → [1,1,2,3]  ← 错误
5

6
# 正确做法：每次从干净的 p 复制
7
p = [2, 3]
8
p_copy = p.copy(); p_copy.insert(0, 1)  # p_copy=[1,2,3]，p 还是 [2,3]
9
p_copy = p.copy(); p_copy.insert(1, 1)  # p_copy=[2,1,3]，p 还是 [2,3]

1
p = [2, 3]
2
p.insert(0, 1)   # → [1, 2, 3]   插到位置 0
3
p.insert(1, 1)   # → [2, 1, 3]   插到位置 1
4
p.insert(2, 1)   # → [2, 3, 1]   插到位置 2（末尾）
5

6
res = []
7
res.append([1,2,3])   # res → [[1,2,3]]
8
res.append([2,1,3])   # res → [[1,2,3],[2,1,3]]

1
比如 nums=[3,3], target=6
2
先存再查：第一次循环，3 存进去，然后查 diff=3，找到自己，返回 [0,0] ← 错误
3
先查再存：第一次循环，查 diff=3，表里还没有，存入 {3:0}
4
          第二次循环，查 diff=3，找到下标0，返回 [0,1] ← 正确

1
def twoSum(self, nums: List[int], target: int) -> List[int]:
2
    # 创建哈希表，存 {数字: 下标}，方便查搭档时直接拿到下标
3
    seen = {}
4

5
    # enumerate 同时拿到下标和值，index 在前，number 在后
6
    for index, number in enumerate(nums):
7
        # 计算当前数字需要的搭档
8
        diff = target - number
9

10
        # 如果搭档已经在表里，直接返回两个下标
11
        if diff in seen:
12
            return [seen[diff], index]
13

14
        # 先查后存：避免同一个元素用两次
15
        seen[number] = index

1
def twoSum(self, numbers: List[int], target: int) -> List[int]:
2
    # 初始化双指针，左指针指向最小值，右指针指向最大值
3
    left = 0
4
    right = len(numbers) - 1
5

6
    # left < right：不能用 <=，因为两个元素不能是同一个
7
    while left < right:
8
        s = numbers[left] + numbers[right]
9

10
        if s > target:
11
            right -= 1   # 和太大，右指针左移，让和变小
12
        elif s < target:
13
            left += 1    # 和太小，左指针右移，让和变大
14
        else:
15
            # 题目下标从 1 开始，所以返回时 +1
16
            return [left + 1, right + 1]
17

18
    # 题目保证有解，这行可写可不写
19
    return []