代码随想录 Day-21｜#530 二叉搜索树的最小绝对差｜#501 二叉搜索树中的众数 ｜#236 二叉树的最近公共祖先

清单

● 530.二叉搜索树的最小绝对差
● 501.二叉搜索树中的众数
● 236. 二叉树的最近公共祖先

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

1. 题目

给你一个二叉搜索树的根节点 root ，返回树中任意两不同节点值之间的最小差值。
差值是一个正数，其数值等于两值之差的绝对值。

2. 思路

中序遍历二叉树，转化成数组，再计算相邻两节点的差值，记录最小值，并在循环结束后返回。

3. 代码实现

#先转化成数组，再计算差值
class Solution:
    def __init__(self):
        self.array = []

    def travel(self,root): #遍历二叉树
        if root is None:
            return
        
        self.travel(root.left)
        self.array.append(root.val)
        self.travel(root.right)

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

        if len(self.array) < 2:
            return 0
        
        min_distance = float('inf')
        for i in range(1, len(self.array)):
            min_distance = min(min_distance, self.array[i] - self.array[i-1])
            
        return min_distance
#双指针
class Solution:
    def __init__(self):
        self.result = float('inf')
        self.pre = None

    def travel(self, cur): #遍历二叉树
        if cur is None:
            return
        
        self.travel(cur.left)
        if self.pre is not None:
            self.result = min(self.result, cur.val - self.pre.val)
        self.pre = cur
        self.travel(cur.right)

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

#501 二叉搜索树中的众数

1. 题目

给你一个含重复值的二叉搜索树（BST）的根节点 root，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。
如果树中有不止一个众数，可以按任意顺序返回。
假定 BST 满足如下定义：
结点左子树中所含节点的值 小于等于 当前节点的值
结点右子树中所含节点的值 大于等于 当前节点的值
左子树和右子树都是二叉搜索树

2. 思路

使用字典进行频率的储存，通过max函数找到字典中的最大频率，再通过遍历字典找到所需要的key值，返回结果list

3. 代码实现

#暴力破解
from collections import defaultdict
class Solution:
    def findBST(self, cur, nums_map):
        if cur is None:
            return 
        nums_map[cur.val] += 1
        self.findBST(cur.left, nums_map)
        self.findBST(cur.right, nums_map)

    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        nums_map = defaultdict(int) #初始化字典
        result = [] #储存众数结果
        if root is None:
            return result

        self.findBST(root, nums_map)
        max_num = max(nums_map.values())
        for key,value in nums_map.items():
            if value == max_num:
                result.append(key)
        return result

#双指针
class Solution:
    def findBST(self, cur):
        if cur is None:
            return
        self.findBST(cur.left)
        if self.pre == None:
            self.count = 1
        elif self.pre.val == cur.val:
            self.count += 1
        else:
            self.count = 1
        self.pre = cur
        if self.count == self.count_max:
            self.result.append(cur.val)
        
        if self.count > self.count_max:
            self.count_max = self.count
            self.result = [cur.val]
        
        self.findBST(cur.right)
        return
    
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        self.pre = None
        self.count_max = 0
        self.count = 0
        self.result = []
        self.findBST(root)
        return self.result

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

1. 题目

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

2. 思路

后序遍历二叉树，当遍历至p/q时 返回根值

3. 代码实现

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