算法记录 | Day21 二叉树

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

二叉树的中序遍历顺序是：左 -> 根 -> 右，二叉搜索树的中序遍历最终得到就是一个升序数组，升序数组中绝对值差的最小值就是比较相邻两节点差值的绝对值
思路：
1.先进行中序遍历变成有序数组
2.计算相邻的插值

    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        res = []
        ans = float('inf')
        def traversal(root):
            if not root:
                return 
            traversal(root.left)
            res.append(root.val)
            traversal(root.right)
        traversal(root)
        for i in range(len(res)-1):
            ans = min(abs(res[i] - res[i+1]),ans)
        return ans

简化：

1.ans用于存储差的绝对值的最小值
2.pre用于保存上一节点的值，用于和当前节点计算差值的绝对值。

class Solution:
    ans = float("inf")
    pre = float("inf")
    def dfs(self, root):
        if not root:
            return
        self.dfs(root.left)
        self.ans = min(self.ans, abs(self.pre-root.val))
        self.pre = root.val
        self.dfs(root.right)

    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        self.dfs(root)
        return self.ans

501.二叉搜索树中的众数

思路：

中序递归遍历二叉树，比较的元素肯定是相邻节点，所以需要再使用一个变量pre来指向前一节点

1.如果当前节点为空，直接返回。

2.递归遍历左子树。

3.比较当前节点和前一节点：

• 如果前一节点为空，则当前元素频率赋值为 1。
• 如果前一节点值与当前节点值相同，则当前元素频率 + 1。
• 如果前一节点值与当前节点值不同，则重新计算当前元素频率，将当前元素频率赋值为 1。

4.判断当前元素频率和最高频率关系：

• 如果当前元素频率和最高频率值相等，则将对应元素值加入 res 数组。
• 如果当前元素频率大于最高频率值，则更新最高频率值，并清空原 res 数组，将当前元素加入 res 数组。

5.递归遍历右子树。

class Solution:
    res = []
    count = 0
    max_count = 0
    pre = None
    def search(self, cur: TreeNode):
        if not cur:
            return
        self.search(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.res.append(cur.val)
        elif self.count > self.max_count:
            self.max_count = self.count
            self.res.clear()
            self.res.append(cur.val)

        self.search(cur.right)
        return

    def findMode(self, root: TreeNode) -> List[int]:
        self.count = 0
        self.max_count = 0
        self.res.clear()
        self.pre = None
        self.search(root)
        return self.res

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

在递归函数有返回值的情况下：如果要搜索一条边，递归函数返回值不为空的时候，立刻返回，如果搜索整个树，直接用一个变量left、right接住返回值，这个left、right后序还有逻辑处理的需要，也就是后序遍历中处理中间节点的逻辑（也是回溯）。

思路：

1.确定递归函数返回值以及参数：输入root，p,q

2.确定终止条件：遇到None，返回； root == q，或者 root == p，找到了返回

3.确定单层递归逻辑：

• left 和 right都不为None，root为最近公共节点
• left为None，right不为None，返回right，说明目标节点是通过right返回的
• left不为None， right为None，返回left
• 二者都为空，返回哪个都行

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if root == p or root == q:
            return root

        if root:
            node_left = self.lowestCommonAncestor(root.left, p, q)
            node_right = self.lowestCommonAncestor(root.right, p, q)
            if node_left and node_right:
                return root
            elif not node_left:
                return node_right
            else:
                return node_left
        return None