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

530.二叉搜索树的最小绝对差 （#783一样）

• 第一反应是暴力解法：遍历所有节点，返回数组进行处理。

# 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:
        self.ans = []
        res = self.helper(root)
        temp = float('inf')
        for i in range(len(res)-1):
            temp = min(temp, abs(res[i] - res[i+1]))
        return temp
        
    
    def helper(self, root): #step1
        #step2
        if root is None:
            return self.ans
        
        #step3
        if root.left:
            self.helper(root.left)
            
        self.ans.append(root.val)
        
        if root.right:
            self.helper(root.right)
            
        return self.ans

• 双指针递归解法：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def getMinimumDifference(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        
        self.temp = float('inf')
        self.pre = None
        return self.helper(root)
        
    
    def helper(self, cur):#step1
        #step2
        if cur is None:
            return 
        #step3
        #左
        self.helper(cur.left)
        #中
        if self.pre:
            self.temp = min(self.temp, cur.val - self.pre.val)
        self.pre = cur
        #右
        self.helper(cur.right)
            
        return self.temp

• 双指针递归法与#98.验证二叉搜索树逻辑是一样的，都是利用双指针 + 中序遍历，不同点在于处理 中 的时候的逻辑。

501.二叉搜索树中的众数

• 双指针递归法：（Carl）

# 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 = TreeNode()
        self.ans = []
        self.count = 0 
        self.maxCount = 0
    
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        return self.helper(root)
        
        
    def helper(self, cur): #step1
        #step2
        if cur is None:
            return None
        #step3
        #左
        self.helper(cur.left)
        #中
        if not self.pre: 
            self.count = 1
        elif self.pre.val == cur.val:
            self.count += 1
        else:
            self.count = 1
        self.pre = cur  #总是忘记更新
        
        if self.count == self.maxCount:
            self.ans.append(cur.val)
        if self.count > self.maxCount:
            self.maxCount = self.count
            self.ans.clear()
            self.ans.append(cur.val)
        #右
        self.helper(cur.right)
        
        return self.ans

注意：总是忘记更新 pre = cur

python知识点：

• 全局变量都在__init__函数里定义，这也就是day20 98.验证二叉搜索树题目下总结的正确（正式）写法

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

• 如果需要从下往上进行处理，那么就要用后序遍历（回溯的过程），也就是先处理 左右 并返回给中，然后再进行 中 的逻辑处理

• trick: 因为题目明确说明 p!=q, 所有如果一侧有p，那么另一侧最多只能有q。

# 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':#step1
        #step2
        if root is None:
            return None
        if root == p or root == q:
            return root
        #step3
        '''因为需要从下往上进行处理，所以需要后序遍历（回溯），也就是先处理 左右 并返回给中，然后再进行 中 的逻辑处理'''
        #左：左子树是否有p或q
        left = self.lowestCommonAncestor(root.left, p, q)
        #右：右子树是否有p或q （因为题目明确说明 p!=q, 所有一侧有p，那么另一侧最多只能有q。这一点很重要！）
        right = self.lowestCommonAncestor(root.right, p, q)
        #中
        if left and right:
            return root
        elif not left and right:
            return right
        elif left and not right:
            return left
        else:
            return None
        

总结：

• 双指针递归法要熟练掌握

• 题目细节需要注意，比如上面的 p!=q 就是关键点

• 分析题目时需要画图，这样能帮助分析终止条件等细节