【代码随想录day18】530.二叉搜索树的最小绝对差 ● 501.二叉搜索树中的众数 ● 236. 二叉树的最近公共祖先

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

问题

题目链接：https://leetcode.cn/problems/minimum-absolute-difference-in-bst/
给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。

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

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

解答

最小值肯定是在上下两个节点产生的，因此我们可以先用中序遍历树，然后返回前后两个元素差的最小值

class Solution:
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        result = []
        def inorder(root):
            if not root: return None
            inorder(root.left)
            result.append(root.val)
            inorder(root.right)
        inorder(root)
        dist = [(result[i+1] - result[i]) for i in range(len(result)-1)]
        return min(dist)

501.二叉搜索树中的众数

问题

题目链接：https://leetcode.cn/problems/find-mode-in-binary-search-tree/
给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。

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

假定 BST 满足如下定义：

结点左子树中所含节点的值 小于等于 当前节点的值
结点右子树中所含节点的值 大于等于 当前节点的值
左子树和右子树都是二叉搜索树

示例：

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

解答

如果是一个普通的树，那么就是先遍历，然后map，排序后输出众数：

from collections import defaultdict

class Solution:
    def searchBST(self, cur, freq_map):
        if cur is None:
            return
        freq_map[cur.val] += 1  # 统计元素频率
        self.searchBST(cur.left, freq_map)
        self.searchBST(cur.right, freq_map)

    def findMode(self, root):
        freq_map = defaultdict(int)  # key:元素，value:出现频率
        result = []
        if root is None:
            return result
        self.searchBST(root, freq_map)
        max_freq = max(freq_map.values())
        for key, freq in freq_map.items():
            if freq == max_freq:
                result.append(key)
        return result

但是搜索树是有序的，因此我们可以采用一个更有效的方法。首先中序遍历，然后比较两个相邻元素的频率。
可以采用双指针，使用pre和cur。cur移动，如果cur与pre相同，则count加一；如果不同，则cur重新开始计数，同时pre更新到当前元素。
上述方法遍历一次能得到所有元素的频率，但如何同时输出最大频率呢。我们使用一个result，记录最大频率，如果cur大于result，则清空result，并将cur作为最大频率记录到result。

class Solution:
    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

用迭代法更容易理解一些：

class Solution:
    def findMode(self, root):
        st = []
        cur = root
        pre = None
        maxCount = 0  # 最大频率
        count = 0  # 统计频率
        result = []

        while cur is not None or st:
            if cur is not None:  # 指针来访问节点，访问到最底层
                st.append(cur)  # 将访问的节点放进栈
                cur = cur.left  # 左
            else:
                cur = st.pop()
                if pre is None:  # 第一个节点
                    count = 1
                elif pre.val == cur.val:  # 与前一个节点数值相同
                    count += 1
                else:  # 与前一个节点数值不同
                    count = 1

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

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

                pre = cur
                cur = cur.right  # 右

        return result

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

问题

题目链接：https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree/
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

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

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出：3
解释：节点 5 和节点 1 的最近公共祖先是节点 3 。

解答

暴力解法就是记录到达p和q的路径，然后从前往后利用双指针找到第一个不相等的值，然后返回上一个。
更有效的方法如下：
如果我们能从下往上处理节点就很简单，此时回溯就是天然的自下而上处理顺序，因此我们采用后序遍历，过程如下
首先使用判断p或q是否在子树里，如果在则返回p或q，不在则返回none
主函数则负责找公共节点：如果左子树有p和q，右子树没有，则进入左节点，继续寻找；反过来同理。
如果左右都有，说明该节点就是公共节点，则返回该节点

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

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

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

上述只解决了情况一，即根节点部位p或q，如果根节点是p或q怎么办。
注意到我们首先判断是的根节点是不是pq，然后才判断root的左右节点是不是pq。
我们假设根节点不是pq，且有一个子树不是None，另一个子树不是空，因此pq都在该子树，假设是左，我们就要判断左孩子，如果此时左孩子是p或q，说说明q或p一定是左孩子的子节点，根据第一行返回该左孩子，该左孩子就是公共节点。
因此以上代码实际解决了所有情况