Day21 | 二叉树

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

def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
    res = []

    def traversal(root):
        if not root:
            return 
        
        traversal(root.left)
        res.append(root.val)
        traversal(root.right)
    
    traversal(root)
    
    ans = inf

    for i in range(1,len(res)):
        ans = min(ans, (res[i]-res[i-1]))
    return ans

因为是BST 可以直接在遍历的时候记录绝对值大小

501. 二叉搜索树中的众数

利用maxcount记录最大频率

增加pre变量存储上一元素以比较，不断更新res数组

# wrong codes
def findMode(self, root: Optional[TreeNode]) -> List[int]:

    res = [root.val]
    pre = root.val
    count = 0
    maxCount = 0
    
    def traversal(root, pre, count, maxCount):
        if not root:
            return
        
        traversal(root.left, pre, count, maxCount)
        if root and root.val == pre:
            count += 1
            if count >= maxCount:
                if count == maxCount:
                    res.append(root.val)
                if count > maxCount:
                    res = [root.val]
                maxCount = count
        else:
            pre = root.val
            count = 1
        # 用self才能更改
        print(pre, count, maxCount)
        traversal(root.right, pre, count, maxCount)

        return
    
    traversal(root, pre, count, maxCount)

    return res

随想录代码：

class Solution:
    def __init__(self):
        self.pre = TreeNode()
        self.count = 0
        self.max_count = 0
        self.result = []

    def findMode(self, root: TreeNode) -> List[int]:
        if not root: return None
        self.search_BST(root)
        return self.result
        
    def search_BST(self, cur: TreeNode) -> None:
        if not cur: return None
        self.search_BST(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.max_count:
            self.result.append(cur.val)
        
        if self.count > self.max_count:
            self.max_count = self.count
            self.result = [cur.val]	# 清空self.result，确保result之前的的元素都失效
        
        self.search_BST(cur.right)

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

看视频思路：

后序：左右中 遇到了返回上层

def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
    
    def search(root):
        if not root:
            return
        if root == p or root == q:
            return root
        
        l = search(root.left)
        r = search(root.right)

        if l and r:
            return root

        # 注意先找到一个的情况
        if l:
            return l
        if r:
            return r
    
    return search(root)