代码随想录算法训练营第二十一天 | 二叉树 part 7 | 530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236. 二叉树的最近公共祖先

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

Leetcode

思路

中序遍历，使用prev指针来对比前后值，再寻找最小的前后差值。

代码

一开始我写出了如下代码，但是有些case过不了。我将prev赋值为node的值

# 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:
        prev = None
        gap = float("inf")

        def helper(root):
            nonlocal prev
            nonlocal gap

            if not root:
                return

            helper(root.left)
            if prev:
                gap = min(gap, root.val - prev)
            prev = root.val

            helper(root.right)
            return

        helper(root)
        return gap

在看了卡哥的代码之后我将prev赋值为node本身，这下过了

# 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:
        prev = None
        gap = float("inf")

        def helper(root):
            nonlocal prev
            nonlocal gap

            if not root:
                return

            helper(root.left)
            if prev:
                gap = min(gap, root.val - prev.val)
            prev = root

            helper(root.right)
            return

        helper(root)
        return gap

两者的区别在于，一个赋值的是int，一个赋值的是Node object。int在为0的时候boolean判断为None，这是一个python的特性。所以在处理一些edge case的时候会跳过差值判定。比如说，在遇到node值为0的时候，会不进入gap = min(gap, root.val - prev.val)的判断。

501.二叉搜索树中的众数

Leetcode

思路

二叉搜索树中序遍历，找到连续出现最多的相同数字，即为众数。我一开始误解为要写众数的个数，把问题简单化了。如果要求众数的话，可能会有多个众数，出现的频率都为最高，比如说[1,1,1,2,3,4,4,4]这个数组内，1和4都是众数。

代码

使用prev指针方便和前一个node的值比对，再使用maxL来记录出现的最大频率，curL来记录当前在遍历的节点值的频率。

# 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]:
        prev = None
        maxL = 0
        curL = 1
        res = []

        def helper(root):
            nonlocal prev
            nonlocal maxL
            nonlocal curL

            if not root:
                return

            helper(root.left)
            if prev:
                if prev.val == root.val:
                    curL += 1
                else:
                    curL = 1
			# 如果大于就全部替代res的元素
            if curL > maxL:
                maxL = curL
                res.clear()
                res.append(root.val)
            # 如果等于就说明有多个众数，放入res即可
            elif curL == maxL:
                res.append(root.val)

            prev = root
            helper(root.right)
            
		# 写完了函数记得要Call，要不然什么都跑不出来
        helper(root)
        return res

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

Leetcode

思路

本题使用回溯的方法来写，回溯需要使用后序遍历。

如何判断一个节点是节点q和节点p的公共祖先？

判断逻辑是 如果递归遍历遇到q，就将q返回，遇到p就将p返回，那么如果 左右子树的返回值都不为空，说明此时的中节点，一定是q 和p的最近祖先。

情况一：

情况二：

这两种情况都可以被刚刚讲的判断逻辑覆盖。

回溯的完整流程图如下：

代码

# 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':

        if root == q or root == p or not root:
            return root

        left = self.lowestCommonAncestor(root.left, p, q) # 左
        right = self.lowestCommonAncestor(root.right, p, q) # 右
		
		# 中
        if not left and not right:
            return None
        elif left and not right:
            return left
        elif not left and right:
            return right
        else:
            return root