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

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

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

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

这个题很容易想到的一个思路就是 使用中序遍历，将二叉搜索树转换成一个有序数组。最小差值只会在相邻元素之间出现。代码如下

常规思路

class Solution:

    def __init__(self):
        self.vec = []
        self.min_value = 0

    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):
        self.vec = []
        self.dfs(root)
        self.min_value = self.vec[-1]
        
        for i in range(1, len(self.vec)):
            temp = self.vec[i] - self.vec[i-1]
            self.min_value = min(self.value, temp
        
        return self.min_value

第二种思路 双指针 

我们是比较相邻的值，可以初始化一个prev指针，和cur指针比较做差，来更新最小绝对值

class Solution:

    def __init__(self):
        self.prev = None
        self.min_value = 0

    def dfs(self, root):
        if not root: return 
        self.dfs(root.left)
        if self.prev is not None:
            self.min_val = min(self.min_value, root.val - prev.val)

        prev = root
        self.dfs(root.right)

    def getMinimumDifference(self, root):
        self.dfs(root)
        return self.min_value

501.二叉搜索树中的众数

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

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

假定 BST 满足如下定义：

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

这个题也有两种思路，一种当做是有序数组，你得到有序数组后，用字典得到最大评率，然后再遍历字典将评率最大的key提出来，保存到字典里面。

常规思路

class Solution:


    def dfs(self, root, freq_map):
        if not root: return 
        self.dfs(root.left)
        freq_map[root.val] += 1
        self.dfs(root.right)

    def getMinimumDifference(self, root):
        from collections import defaultdict
        freq_map = defaultdict(int)
        self.dfs(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
            

第二种也是用双指针

虽然逻辑要复杂一点。也是一个指针指向前节点，一个指针指向后节点。如果相等，保留的count+1,比较是否是max_count，是的话，加入到最终的result，如果大于max_count，将result请0，然后再加目前的root，不相等，重置为1

双指针代码

class Solution:
    def __init__(self):
        self.prev = None
        self.count = 1
        self.max_count = 0
        self.result = []

    def dfs(self, root):
        if not root: return

        self.dfs(root.left)

        if self.pre is None:
            self.count = 1

        elif self.prev.val == root.val:
            
            self.count += 1
        else:
            self.count = 1  
        
        if self.count == self.max_count:
            self.result.append(root.val)

        if self.count > self.max_count:
            self.max_count = self.count
            self.result = [root.val]

        self.dfs(root.right)

        return
    
    def finMode(self, root):
        self.count = 0
        self.max_count = 0
        self.pre = None
        self.result = []

        self.dfs(root)
        return self.result
            

        

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

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

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

这个题是自下向上的逻辑，但是二叉树的入口是根节点，比较搞不懂该如何遍历。

其实二叉树的后序遍历，就是自下向上递归回溯的。这点不是很好理解。具体可看代码随想录关于这个的讲解。我理解的是我们要去找节点，采用后序的方式，我们会一直从下网上，如果找到了，我们就返回这个节点，因为毕竟你回去往上走，左右中，中就是接受你的结果。如果你的中返回的左，右都不为空，那就该返回你的中，说明已经找到最深的父节点。如果有一个为空，一个不为空，说明你要找的父节点不是此时的中，你需要返回找到的这个节点，然后继续往上找另一个节点所在的子树在哪里。直到找到不为空，返回的那个父节点。

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

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

        if (left is not None and right is not None):
            retutn root

        if (left is None and right is not None):
            return right

        if (left is not None and right is None):
            return left

        if (left is None and right is None):
            return None