1
class Solution:
2
    # 这里需要比较相邻节点的值，所以需要 左 -> 根 -> 右 的中序遍历
3
    # 通过维护一个前一个节点 prev 和最小差 res 来计算
4
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
5
        self.res = float('inf')  # 最小差值，初始为正无穷
6
        self.prev = None         # 记录前一个节点
7
        self.traverse(root)      # 执行中序遍历
8
        return self.res
9

10
    def traverse(self, root):
11
        if not root:
12
            return
13
        self.traverse(root.left)
14
        if self.prev:
15
            # 当前节点与前一个节点差值，更新最小差值
16
            self.res = min(self.res, root.val - self.prev.val)
17
        self.prev = root
18
        self.traverse(root.right)

1
class Solution:
2
    # 这里需要找到出现次数最多的值，跟前一个节点的值进行比较
3
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
4
        # wid 用于存储出现次数最多的值
5
        self.wid = []
6
        # prev 用于记录前一个节点
7
        self.prev = None
8
        # cur_count 用于记录当前值的出现次数
9
        self.cur_count = 0
10
        # max_count 用于记录出现次数的最大值
11
        self.max_count = 0
12
        self.traverse(root)
13
        return self.wid
14

15
    def traverse(self, root):
16
        if not root:
17
            return
18

19
        self.traverse(root.left)
20

21
        if not self.prev:
22
            # 如果prev是None，说明这是第一个节点，初始化cur_count和max_count
23
            self.cur_count = 1
24
            self.max_count = 1
25
            self.wid.append(root.val)
26
        else:
27
            # 如果prev不是None，比较当前节点和前一个节点的值
28
            if root.val == self.prev.val:
29
                # 如果相等，增加当前值的计数
30
                self.cur_count += 1
31
                if self.cur_count == self.max_count:
32
                    # 如果当前计数等于最大计数，添加到结果列表
33
                    self.wid.append(root.val)
34
                elif self.cur_count > self.max_count:
35
                    # 如果当前计数大于最大计数，更新最大计数并重置结果列表
36
                    self.wid = []
37
                    self.max_count = self.cur_count
38
                    self.wid.append(root.val)
39
            else:
40
                # 如果不相等，重置计数
41
                self.cur_count = 1
42
                if self.cur_count == self.max_count:
43
                    # 如果当前计数等于最大计数，添加到结果列表
44
                    self.wid.append(root.val)
45
        self.prev = root
46
        self.traverse(root.right)

1
class Solution:
2
    # 有三种情况：
3
    # 1. 如果 p 和 q 都小于 root，说明最近公共祖先在左子树
4
    # 2. 如果 p 和 q 都大于 root，说明最近公共祖先在右子树
5
    # 3. 否则，当前 root 就是最近公共祖先
6
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
7
        if root is None:
8
            return None
9
        # 如果 p 和 q 都在 root 的左子树
10
        if p.val < root.val and q.val < root.val:
11
            return self.lowestCommonAncestor(root.left, p, q)
12
        # 如果 p 和 q 都在 root 的右子树
13
        elif p.val > root.val and q.val > root.val:
14
            return self.lowestCommonAncestor(root.right, p, q)
15
        # 如果 p 和 q 分别在 root 的左右两边，或者有一个等于 root，则 root 就是最近公共祖先
16
        else:
17
            return root