算法打卡day18

今日任务：

1）530.二叉搜索树的最小绝对差

2）501.二叉搜索树中的众数

3）236.二叉树的最近公共祖先

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

题目链接： 530. 二叉搜索树的最小绝对差 - 力扣（LeetCode）

给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。

差值是一个正数，其数值等于两值之差的绝对值。

提示：

树中节点的数目范围是 [2, 104]

0 <= Node.val <= 105

示例 1：

输入：root = [4,2,6,1,3]

输出：1

示例 2：

输入：root = [1,0,48,null,null,12,49]

输出：1

文章讲解： 代码随想录 (programmercarl.com)

视频讲解： 二叉搜索树中，需要掌握如何双指针遍历！| LeetCode：530.二叉搜索树的最小绝对差哔哩哔哩bilibili

思路：

搜索二叉树的常规做法，中序遍历，记录前一个节点值，与当前节点求差值。见前一天打卡，98.验证二叉搜索树。这题是98题的变体

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.div = float('inf')

    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        # 测试数集中没有空，这步可以不要
        if not root:
            return 0

        # 左
        self.getMinimumDifference(root.left)

        # 中
        if self.pre is not None:
            self.div = min(self.div, abs(root.val - self.pre))

        self.pre = root.val

        # 右
        self.getMinimumDifference(root.right)

        return self.div

501.二叉搜索树中的众数

题目链接： 501. 二叉搜索树中的众数 - 力扣（LeetCode）

给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。

如果树中有不止一个众数，可以按 任意顺序 返回。

假定 BST 满足如下定义：

1.结点左子树中所含节点的值 小于等于 当前节点的值

2.结点右子树中所含节点的值 大于等于 当前节点的值

3.左子树和右子树都是二叉搜索树

示例 1：

输入：root = [1,null,2,2]

输出：[2]

示例 2：

输入：root = [0]

输出：[0]

提示：

树中节点的数目在范围 [1, 104] 内

-105 <= Node.val <= 105

文章讲解： 代码随想录 (programmercarl.com)

视频讲解： 不仅双指针，还有代码技巧可以惊艳到你！ | LeetCode：501.二叉搜索树中的众数哔哩哔哩bilibili

思路：

最直白的方法可以遍历整个树，并采用字典记录节点值 ，以及已经出现的次数。

然后，我们通过找到这个字典中value的最大值，并将其key添加至返回列表中

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.freq = {}

    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        # 开始递归
        self.traversal(root)

        # 递归完成，求字典中最大出现频率
        max_sum = max(self.freq.values())
        # 将最大频率出现的数添加到数组中
        res = []
        for key, value in self.freq.items():
            if value == max_sum:
                res.append(key)
        return res

    def traversal(self, node):
        # 终止
        if not node:
            return
        # 左
        self.traversal(node.left)
        # 中
        self.freq[node.val] = self.freq.get(node.val, 0) + 1
        # 右
        self.traversal(node.right)

也可以不用全局变量

class Solution:
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        # 开始递归
        freq = {}
        self.traversal(root, freq)

        # 递归完成，求字典中最大出现频率
        max_sum = max(freq.values())
        # 将最大频率出现的数添加到数组中
        res = []
        for key, value in freq.items():
            if value == max_sum:
                res.append(key)
        return res

    def traversal(self, node, freq):
        # 终止
        if not node:
            return
        # 左
        self.traversal(node.left, freq)
        # 中
        freq[node.val] = freq.get(node.val, 0) + 1
        # 右
        self.traversal(node.right, freq)

以上是将树遍历完，然后得到频率的字典，最后找到结果。

代码随想录提供了一种动态更新新出现次数count，高频maxCount以及存放高频值的结果表result的方法，具体可以去看代码随想录。（这部分理解，但没自己写）

class Solution3:
    def __init__(self):
        self.maxCount = 0  # 最大频率
        self.count = 0  # 统计频率
        self.pre = None
        self.result = []

    def searchBST(self, cur):
        if cur is None:
            return

        self.searchBST(cur.left)  # 左
        # 中
        if self.pre is None:  # 第一个节点
            self.count = 1
        elif self.pre.val == cur.val:  # 与前一个节点数值相同
            self.count += 1
        else:  # 与前一个节点数值不同
            self.count = 1
        self.pre = cur  # 更新上一个节点

        if self.count == self.maxCount:  # 如果与最大值频率相同，放进result中
            self.result.append(cur.val)

        if self.count > self.maxCount:  # 如果计数大于最大值频率
            self.maxCount = self.count  # 更新最大频率
            self.result = [cur.val]  # 很关键的一步，不要忘记清空result，之前result里的元素都失效了

        self.searchBST(cur.right)  # 右
        return

    def findMode(self, root):
        self.count = 0
        self.maxCount = 0
        self.pre = None  # 记录前一个节点
        self.result = []

        self.searchBST(root)
        return self.result

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

题目链接： 236. 二叉树的最近公共祖先 - 力扣（LeetCode）

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为："对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。"

示例 1:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1

输出: 3 解释: 节点 5 和节点 1 的最近公共祖先是节点 3。

示例 2:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4

输出: 5 解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。

说明:

所有节点的值都是唯一的。

p、q 为不同节点且均存在于给定的二叉树中。

文章讲解： 代码随想录 (programmercarl.com)

视频讲解： 自底向上查找，有点难度！ | LeetCode：236. 二叉树的最近公共祖先哔哩哔哩bilibili

思路：

首先分析如果某节点node为p，q的最近公共祖先，那么p，q会出现以下三种情况：

1.p 和 q 在 node 的子树中，且分列 node 的异侧（即分别在左、右子树中）；

2.p=node，且 q 在 node 的左或右子树中；

3.q=node，且 p 在 node 的左或右子树中；

这题做法比较巧妙

1）考虑通过递归对二叉树进行先序遍历（中左右），当遇到节点p或者q时返回节点p或q。

2）从底至顶回溯当节点p，q

• 如果node的左右不为空，说明p，q在节点node异侧，节点node即为最近公共节点，返回节点node
• 如果node只有一侧不为空，返回这一侧传上来的值（这里其实也包含了两种情况，一种是已经找到最近公共节点，返回是最近公共节点，一种是还没有找到最近公共节点，返回的是p或q节点，不管是哪一种情况，直接继续返回传上来的值即可）
• 如果两侧均不为空，则还没有找到p，q，更没有找到最近公共节点

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if root == q or root == p or root is None:
            return root

        left = self.lowestCommonAncestor(root.left, p, q)
        right = self.lowestCommonAncestor(root.right, p, q)


        if left is not None and right is not None:
            return root

        if left is None and right is not None:
            return right
        elif left is not None and right is None:
            return left
        else:
            return None