代码随想录算法训练营第十九天 | 530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236. 二叉树的最近公共祖先

一、530.二叉搜索树的最小绝对差

题目链接：530. 二叉搜索树的最小绝对差 - 力扣（LeetCode）
文章讲解：代码随想录 (programmercarl.com)——530.二叉搜索树的最小绝对差
视频讲解：二叉搜索树中，需要掌握如何双指针遍历！| LeetCode：530.二叉搜索树的最小绝对差_哔哩哔哩_bilibili

直白思路：中序遍历后，计算两两节点差值。
双指针法思路：定义一个cur 一个pre两个指针，用cur-pre，用res记录下来差值，res最小值即为所求。

"""
中序遍历
"""
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def __init__(self):
        # 初始一个最大值，因为要求最小值
        self.res = float('inf')
        # 定义一个指针 
        self.pre = None

    def traversal(self, cur):
        # 终止条件
        if not cur:
            return
        
        # 单层递归逻辑
        # 左
        self.traversal(cur.left)
        
        # 中，比较两个节点差值，记录差值
        if self.pre:
            # 对比之前的最小值和当前差值
            self.res = min(self.res, cur.val - self.pre.val)
        # 使pre紧跟cur，一直是cur的前一个节点
        self.pre = cur

        # 右
        self.traversal(cur.right)


    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        self.traversal(root)

        return self.res

Note：遇到二叉树求最值得题目，想一下二叉树遍历时候是否有序！

二、501.二叉搜索树中的众数

题目链接：501. 二叉搜索树中的众数 - 力扣（LeetCode）
文章讲解：代码随想录 (programmercarl.com)——501.二叉搜索树中的众数
视频讲解：不仅双指针，还有代码技巧可以惊艳到你！ | LeetCode：501.二叉搜索树中的众数_哔哩哔哩_bilibili

双指针思路：二叉搜索树首选中序遍历。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def __init__(self):
        self.pre = None 
        self.count = 0          # 统计频率
        self.max_count = 0      # 最大频率
        self.result = []

    
    def traversal(self, cur):
        if not cur:
            return

        # 单层递归逻辑
        # 左
        self.traversal(cur.left)

        # 中
        if not self.pre:
            self.count = 1
        elif self.pre.val == cur.val:
            self.count += 1
        elif self.pre.val != cur.val:
            self.count = 1
        self.pre = cur          # pre指针紧跟cur

        # 如果当前频率和最大频率相等，将元素放进数组
        if self.count == self.max_count:
            self.result.append(cur.val)

        # 如果当前频率大于最大频率，更新max_count，清空result，后加入新元素
        if self.count > self.max_count:
            self.max_count = self.count
            self.result.clear()
            self.result.append(cur.val)
        
        # 右
        self.traversal(cur.right)

        return


    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return

        self.traversal(root)

        return self.result

三、236. 二叉树的最近公共祖先

题目链接：236. 二叉树的最近公共祖先 - 力扣（LeetCode）
文章讲解：代码随想录 (programmercarl.com)——236. 二叉树的最近公共祖先
视频讲解：自底向上查找，有点难度！ | LeetCode：236. 二叉树的最近公共祖先_哔哩哔哩_bilibili

思路：如果遇到了p，q就分别从下往上回溯，节点左右均不为空，中一定就是最近交汇节点。
遍历顺序：后序遍历

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        # 确定终止条件，遇到空返回
        if not root:
            return root
        # 遇到p, q返回，这段代码包含了p或q本身为最近公共祖先的情况
        if root == p or root == q:
            return root

        # 单层递归逻辑
        # 左，告诉我们左子树是否出现p, q
        left = self.lowestCommonAncestor(root.left, p, q)

        #右
        right = self.lowestCommonAncestor(root.right, p, q)

        # 中
        # 如果左右子树都不为空，说明出现了p或q，节点向上返回
        if left and right:
            return root
        # 如果左子树为空，右子树不为空，即左子树没有目标值，右子树有目标值，将右节点继续向上返回
        elif not left and right:
            return right
        # 如果左子树不为空，右子树为空，即左子树有目标值，右子树没有目标值，将左节点继续向上返回
        elif left and not right:
            return left
        # 如果左右节点都为空，向上返回空
        elif not left and not right:
            return None