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

530.二叉搜索树的最小绝对差   代码随想录

方法一：先进行中序遍历（因为中序遍历得到的结果经过了排序），结果放入一个数组，再求最小绝对差

# 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
        """
        nums = self.traversal(root)
        res = float('inf')
        for i in range(1, len(nums)):
            res = min(res, nums[i]-nums[i-1])
        return res

    def traversal(self, root):
        if not root:
            return []
        left = self.traversal(root.left)
        right = self.traversal(root.right)
        return left+[root.val]+right

方法二：定义一个pre指针，一边遍历一边更新res

# 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.pre = None
        self.res = float('inf')

    def getMinimumDifference(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        return self.traversal(root)

    def traversal(self, cur):
        if cur is None:
            return 
        left = self.traversal(cur.left)  # 左
        if self.pre:
            self.res = min(cur.val - self.pre.val, self.res)  # 中
        self.pre = cur
        right = self.traversal(cur.right)  # 右
        return self.res

501.二叉搜索树中的众数  代码随想录

有点难，看了题解又恍然大悟了。。。

# 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.pre = None  
        self.count = 0     
        self.maxcount = 0  # 用于记录出现最多的次数
        self.res = []      # 用于记录当前数出现的次数

    def findMode(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        return self.traversal(root)
    
    def traversal(self, cur):
        if not cur:
            return 
        left = self.traversal(cur.left)  # 左
        if self.pre is None:  # 中   第一个节点
            self.count = 1
        elif cur.val == self.pre.val:  # 后一个与前一个节点相等
            self.count += 1
        else:         # 不相等则count重新初始化为1
            self.count = 1
        self.pre = cur

        if self.count == self.maxcount:
            self.res.append(cur.val)
        
        if self.count > self.maxcount:  # 若当前元素的出现次数比maxcount多，则将maxcount更新
            self.maxcount = self.count
            self.res = [cur.val]       # 同时res里之前存的元素都要清空
        
        right = self.traversal(cur.right)  # 右
        return self.res

236. 二叉树的最近公共祖先   代码随想录

情况一：一个节点左右两侧分别有p、q，则该节点为公共祖先

情况二：节点本身为p，它有一个子孙节点q，则p本身就是最近公共祖先

采用后序遍历，这样可以将左右子树的信息返回给中间节点

# 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
        """
        return self.traversal(root, p, q)
    
    def traversal(self, root, p, q):
        if not root:
            return None
        if root == p or root == q:
            return root
        left = self.traversal(root.left, p, q)
        right = self.traversal(root.right, p, q)
        if left and right:  # 左右子树的返回值均不为空，则此时的中节点就是最近公共祖先
            return root
        elif left and not right:  # 把不为none的返回给上一层，因为如果没找到会返回none
            return left
        elif right and not left:
            return right
        else:
            return None