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

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

递归：

中序遍历，记录prev

自己写出来了！

class Solution:
    def __init__(self, res = float('inf'), prev = None):
        self.res = res
        self.prev = prev
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        if not root:
            return
        self.getMinimumDifference(root.left)
        if self.prev:
            self.res = min(self.res, abs(root.val - self.prev.val))
        self.prev = root
        self.getMinimumDifference(root.right)

        return self.res

迭代：

class Solution:
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        if not root:
            return
        res = float('inf')
        prev = None
        stack = []
        node = root
        while stack or node:
            while node:
                stack.append(node)
                node = node.left
            node = stack.pop()
            if prev:
                res = min(res, abs(node.val - prev.val))
            prev = node
            node = node.right
        return res

501. 二叉搜索树中的众数

利用BST的中序非递减特性，使用prev指针指向前一个，用于和当前root比较val值，如果相等，则当前值的count+1，如果不等，重置为1；然后处理result数组，如果count比max_count要大，更新max_count并且清空result并把当前val放进去，如果相等，单纯的加入val进result；然后更新prev。

class Solution:
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        if not root: return []
        
        self.count = 1
        self.max_count = 0
        self.result = []
        self.prev = None

        def inorder(root):
            if not root:
                return
            inorder(root.left)
            if self.prev:
                if root.val == self.prev.val:
                    self.count += 1
                else:
                    self.count = 1
            if self.count > self.max_count:
                self.max_count = self.count
                self.result = [root.val]
            elif self.count == self.max_count:
                self.result.append(root.val)
            self.prev = root
            inorder(root.right)

        inorder(root)
        return self.result

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

递归一：

找路径，然后找路径从左到右最后一个公共节点。

from collections import deque
class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        self.path = deque()
        self.pPath = deque()
        self.qPath = deque()
        res = None

        def findPath(root, p, q):
            if not root:
                return
            self.path.append(root)
            if root == p:
                self.pPath = deque(self.path)
            if root == q:
                self.qPath = deque(self.path)
            findPath(root.left, p, q)
            findPath(root.right, p, q)
            self.path.pop()

        findPath(root,p,q)
        while self.pPath and self.qPath and self.pPath[0] == self.qPath[0]:
            res = self.pPath.popleft()
            self.qPath.popleft()
        return res

*递归二：

基本情况：

• 如果当前节点是 None，返回 None。这意味着我们已经到达了树的底部，没有找到 p 或 q。
• 如果当前节点等于 p 或 q，返回当前节点。这意味着我们找到了 p 或 q 中的一个。

递归搜索：

• 对当前节点的左子树调用 lowestCommonAncestor，寻找 p 或 q。
• 对当前节点的右子树调用 lowestCommonAncestor，寻找 p 或 q。

回溯确定公共祖先：

• 如果 p 和 q 分别位于当前节点的左右子树中，那么当前节点就是它们的最近公共祖先。
• 如果 p 和 q 都不在左子树中，那么它们必定都在右子树中，返回右子树的结果。
• 如果 p 和 q 都不在右子树中，那么它们必定都在左子树中，返回左子树的结果。

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

今日总结：

第一题第二题自己能写出来了。

第三题，这咋能想到这么写！！！