代码训练营 ｜ Day 21 二叉树07

1、

530. Minimum Absolute Difference in BST

注意是二叉搜索树，二叉搜索树可是有序的。

遇到在二叉搜索树上求什么最值啊，差值之类的，就把它想成在一个有序数组上求最值，求差值，这样就简单多了。

# 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.vec = []
        ## self.vec.clear() 不需要
        #要+self
        self.traversal(root)
        ##if len(self.vec) < 2:
        ##    return 0 ##剪枝：非必要
        min_value = float('inf') #记住这个最小值
        for i in range(1,len(self.vec)): #这个必须从1开始
            min_value = min(min_value,self.vec[i]-self.vec[i-1])
        return min_value

    def traversal(self,root):
        ## 忘记记录终止条件了
        if root is None:
            return
        self.traversal(root.left)
        self.vec.append(root.val)
        self.traversal(root.right)
    
    def __init__(self):
        self.vec = []

还可以在遍历的时候就把最小值计算

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)  # 右

2、

501. Find Mode in Binary Search Tree

首先分：

1、如果不是BST，只是Binary Tree的情况：

Traverse the tree and use map to record the key and value, if key exist, then value++

2、是BST

remember it must be in-order to traverse, buz just in-order traverse then it will be orderly.

应该是先遍历一遍数组，找出最大频率（maxCount），然后再重新遍历一遍数组把出现频率为maxCount的元素放进集合。（因为众数有多个）

1) 利用字典

# 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
from collections import defaultdict

class Solution:
    def searchBST(self, cur, freq_map):
        if cur is None:
            return
        freq_map[cur.val] += 1  # 统计元素频率
        self.searchBST(cur.left, freq_map)
        self.searchBST(cur.right, freq_map)

    def findMode(self, root):
        freq_map = defaultdict(int)  # key:元素，value:出现频率
        result = []
        if root is None:
            return result
        self.searchBST(root, freq_map)
        max_freq = max(freq_map.values())
        for key, freq in freq_map.items():
            if freq == max_freq:
                result.append(key)
        return result

2) 利用BST性质

自己写的

# 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 findMode(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        global result = []
        global count = 0
        global maxCount = 0
        global pre = None
        result.clear

        traversal(root)
        return result


        
    # 自己写的
    
    def traversal(self, root):
        if root is None:
            return
        self.traversal(root.left)
        # 中的处理逻辑不一样
        if (pre == None): # 第一个节点
            count = 1 
        elif (pre.val == root.val): # 如果两个节点一样
            count += 1
        else: #如果两个节点不一样
            count = 1

        pre = root # 更新上一个节点
        # 如果count和最大值相同，则加入array中
        if (count == maxCount):
            result.append(root.val)
        
        # 更新的逻辑
        if (count > maxCount):
            maxCount = count
            result.clear
            result.append(root.val)

        #self.vec.append(root.val)
        self.traversal(root.right)

VS答案：（global在 init定义）

class Solution:
    def __init__(self):
        self.maxCount = 0  # 最大频率
        self.count = 0  # 统计频率
        self.pre = None
        self.result = []

    def searchBST(self, cur):
        if cur is None:
            return

        self.searchBST(cur.left)  # 左
        # 中
        if self.pre is 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:  # 如果与最大值频率相同，放进result中
            self.result.append(cur.val)

        if self.count > self.maxCount:  # 如果计数大于最大值频率
            self.maxCount = self.count  # 更新最大频率
            self.result = [cur.val]  # 很关键的一步，不要忘记清空result，之前result里的元素都失效了

        self.searchBST(cur.right)  # 右
        return

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

        self.searchBST(root)
        return self.result

3、

236. Lowest Common Ancestor of a Binary Tree

Backtrace --> post order

right and left same have number then return the common ancestor

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        if root is None:
            return 
        
        # post order trackback
        # 找到节点的逻辑
        if (root == q || root == q || root is None):
            return root
        # 判断right and left
        # 忘记了，其实在此之前要先回溯循环
        left = self.lowestCommonAncestor(self, root, p, q) #root.left
        
        
        ##if lowestCommonAncestor(root.left):   
        ##    return right
        if left is not None and right is not None: