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

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 __init__(self):
        self.pre = None
        self.minDiff = float('inf')
    
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        if not root:
            return
        self.getMinimumDifference(root.left)
        if self.pre:
            self.minDiff = min(self.minDiff, root.val - self.pre.val)
        self.pre = root
        self.getMinimumDifference(root.right)

        return self.minDiff

 或者中序的迭代写法：

# 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:
        res = float('inf')
        stack = []
        cur = root
        pre = None

        while cur or stack:
            while cur:
                stack.append(cur)
                cur = cur.left
            cur = stack.pop()

            if pre:
                res = min(cur.val - pre.val, res)

            pre = cur
            cur = cur.right

        return res

 501.二叉搜索树中的众数

还是双指针+中序遍历：

# 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 __init__(self):
        self.pre = None
        self.maxCount = 1
        self.curCount = 0
        self.res = []
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        self.pre = root
        
        def dfs(root):
            if not root:
                return
            
            dfs(root.left)

            if root.val == self.pre.val:
                self.curCount += 1
                if self.curCount == self.maxCount:
                    self.res.append(root.val)
                elif self.curCount > self.maxCount:
                    self.res = [root.val]
                    self.maxCount = self.curCount
            else:
                self.curCount = 1
                if self.maxCount == 1:
                    self.res.append(root.val)

            self.pre = root

            dfs(root.right)
        dfs(root)
        return self.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]:
        res = []
        stack = []
        cur = root
        pre = None
        maxCount = 0
        curCount = 0

        while cur or stack:
            while cur:
                stack.append(cur)
                cur = cur.left
            
            cur = stack.pop()
            if not pre:
                curCount = 1
            elif pre.val == cur.val:
                curCount += 1
            else:
                curCount = 1
            if curCount == maxCount:
                res.append(cur.val)
            elif curCount > maxCount:
                maxCount = curCount
                res = [cur.val]
            pre = cur
            cur = cur.right
        return res

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

这题主要就是如何把找到的结果传回来比较tricky

# 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 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 left and right:
            return root
        return left if left else right