代码随想录算法训练营第二十一天【二叉树】｜530，501，236

530. Minimum Absolute Difference in BST

用双指针法，pre总在cur前一位

# 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 __init__(self):
        self.result = float("inf")
        self.pre = None
    def traversal(self,cur):
        if cur is None:
            return
        self.traversal(cur.left) #左
        if self.pre is not None: #中，双指针
            self.result = min(self.result,cur.val-self.pre.val)
        self.pre = cur
        self.traversal(cur.right) #右
    def getMinimumDifference(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        self.traversal(root)
        return self.result

        

501. Find Mode in Binary Search Tree

因为是二叉搜索树，所以中序遍历就是有序的，然后就用双指针法，只要前后pre和cur相等就count+1。

然后同时有个result数组实时更新有maxcount的val。只要有count>maxcount就清空数组加入新val

便利一遍就可以统计出来

# 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 __init__(self):
        self.maxCount=0
        self.count = 0
        self.pre = None
        self.result = []
    
    def traversal(self,cur):
        if cur is None:
            return
        #左
        self.traversal(cur.left)
        #中
        if self.pre == None:
            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.result.append(cur.val)
        if self.count > self.maxCount:
            self.maxCount = self.count
            self.result = [cur.val]
        #右
        self.traversal(cur.right)
        return

        

    def findMode(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        self.count = 0
        self.maxCount = 0
        self.pre = None  # 记录前一个节点
        self.result = []

        self.traversal(root)
        return self.result

236. Lowest Common Ancestor of a Binary Tree

回溯：用后序遍历（左右中里的中在回溯，因为中的逻辑要根据左右的值来判断），且从下往上处理一定要用后序遍历

要理解如果返回值left为空，right不为空为什么要返回right，为什么可以用返回right传给上一层结果

very nuanced

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

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        if root == None:
            return None
        if root == p or root == q:
            return root
        #左
        left = self.lowestCommonAncestor(root.left,p,q)
        #右
        right = self.lowestCommonAncestor(root.right,p,q)
        #中
        if left != None and right != None:
            return root
        if left == None and right != None: 
            return right
        elif left != None and right == None:
            return left
        else:
            return None