DAY21 二叉树part07

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

• 【注意】二叉搜索树性质：通过中序遍历二叉搜索树得到的关键码序列是一个递增序列

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        # 首先中序遍历二叉搜索树，再去计算两个节点间的最小值
        mid = []
        def dfs(root):
        	if not root:return
        
        	dfs(root.left)
        	mid.append(root.val)
        	dfs(root.right)
        dfs(root)
        # return mid
        divd = []
        for i in range(len(mid)-1):
            divd.append(mid[i+1]-mid[i])
        divd.sort()
        return divd[0]

501.二叉搜索树中的众数

python可以直接用中序遍历＋Counter函数去做，这里我们已经知道counter.most_common()传进去一个可选参数n(代表获取数量最多的前n个元素，如果不传参数，代表返回所有结果)

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        order = []
        # 中序遍历二叉搜索树
        def dfs(root):
            if not root:return
            dfs(root.left)
            order.append(root.val)
            dfs(root.right)
        dfs(root)
        # return order
        res = []
        # from collections import Counter
        count = Counter(order)
        max_value = count.most_common(1)[0][1]
        for k,v in count.most_common():
            if v >=max_value:
                res.append(k)
        return res
        

这个思路想到过，但没想好怎么去维护这个最大的频数，看完这个代码傻眼了，只能说写中序遍历的时候我还在想要生成最后的遍历结果，但这个直接调用函数进行维护了。我格局小了！

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        # 在遍历中利用若干变量统计众数
        """
        nonlocal maxcnt 目前最大的频数
        nonlocal base 上一次统计的数
        nonlocal cnt 上一次统计的数的频数
        nonlocal ans 记录最大频次的数的数组
        """
        maxcnt = 1
        base = float('-inf')
        cnt = 1
        ans = []
        def update(val):
            nonlocal maxcnt
            nonlocal base
            nonlocal cnt
            nonlocal ans
            # 若当前遍历节点值与前一个节点值相同则将当前频数加一
            if val == base:
                cnt +=1
            # 否则将base改为当前节点值，频数变为1
            else:
                base = val
                cnt=1
            # 如果当前节点对应的值的频数等于最大频数则将当前节点值加入最终输出数组中
            if cnt == maxcnt:
                ans.append(val)
            # 若大于，则将ans清空为仅余当前节点值的数组，并且更新最大频数
            if cnt > maxcnt:
                ans = [val]
                maxcnt = cnt
        def dfs(node):
            if not node:return
            dfs(node.left)
            # 我认为此处思路较为关键（个人看法）
            update(node.val)
            dfs(node.right)
        dfs(root)
        return ans

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

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        # 为什么root为空的时候也返回了root节点
        if not root or root == p or root==q:return root
        left = self.lowestCommonAncestor(root.left,p,q)
        right = self.lowestCommonAncestor(root.right,p,q)
        if not left:return right
        if not right:return left
        return root

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        def dfs(node,target,path):
            if not node:return
            # 若当前节点是p或q节点，则将该节点加入path中
            if node == target:
                path.append(node)
                return target

            # 递归遍历左子树并检查目标节点是否找到
            val = dfs(node.left,target,path)  
            if val:
                path.append(node)
                return target
            # 递归遍历右子树并检查目标节点是否找到
            val = dfs(node.right,target,path)
            if val:
                path.append(node)
                return target
        
        p_path,q_path = [],[]
        dfs(root,p,p_path)
        dfs(root,q,q_path)

        # 若p在q的路径中，则说明p是pq的
        if p in q_path: return p
        # 若q在p的路径中，则说明q是pq的
        if q in p_path:return q
        for i in p_path:
            if i in q_path:
                return i