代码随想录算法训练营Day21 | 530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236. 二叉树的最近公共祖先 | Python | 个人记录向

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

代码随想录：530.二叉搜索树的最小绝对差
Leetcode：530.二叉搜索树的最小绝对差

做题

一开始没做出来，看了一眼文章，发现用二叉搜索树的特性（中序遍历获得有序数组）就可以。

class Solution:
    def __init__(self):
        self.vec = []

    def dfs(self, root):
        if not root:
            return
        self.dfs(root.left)
        self.vec.append(root.val)
        self.dfs(root.right)

    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        self.dfs(root)
        self.res = float('inf')
        for i in range(1, len(self.vec)):
            cur = self.vec[i] - self.vec[i-1]
            self.res = min(self.res, cur)
        return self.res

看文章

仍然是利用二叉搜索树的特性，但可以在dfs的过程中就记录最小值。
做501的时候发现，重点就在dfs中利用双指针比较前后的值，并记录最小值。具体代码如下：

class Solution:
    def __init__(self):
        self.result = float('inf')
        self.pre = None

    def traversal(self, cur):
        if cur is None:
            return
        self.traversal(cur.left)  # 左
        if self.pre is not None:  # 中
            self.result = min(self.result, cur.val - self.pre.val)
        self.pre = cur  # 记录前一个
        self.traversal(cur.right)  # 右

    def getMinimumDifference(self, root):
        self.traversal(root)
        return self.result

501.二叉搜索树中的众数

代码随想录：501.二叉搜索树中的众数
Leetcode：501.二叉搜索树中的众数

做题

尝试转成有序数组，本来想用字典来统计频率，以为时间复杂度高了，就放弃了，但其实思路方向其实对了…这里说明，不管什么方法，应该要先AC再说。

看文章

如果不是二叉搜索树：

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

如果是二叉搜索树，那在遍历二叉搜索树的过程中，就可以记录当前最大频率并及时更新结果集。代码如下：

class Solution:
    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：236. 二叉树的最近公共祖先

做题

无思路。

看文章

直接想到的应该是从下往上遍历，后序遍历就可以实现。

class Solution:
    def lowestCommonAncestor(self, root, p, q):
        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

以往忽略的知识点小结

• 二叉搜索树的中序遍历，可得到有序数组，在遍历中完成任务，即可减少计算量
• 最小公共祖先主要是理解思路，代码反而不难

个人体会

完成时间：2h。
心得：题比较难，二叉搜索树要注意特性（中序遍历可得到有序数组），可以在遍历中完成任务；最小公共祖先感觉比较难理解，但实际代码比较简单。

​