DAY18 二叉树part6

求一个好offer拜托拜托

已于 2024-10-09 14:55:04 修改

阅读量537

点赞数 10

文章标签：数据结构

于 2024-10-09 14:53:46 首次发布

本文链接：https://blog.csdn.net/weixin_44959140/article/details/142749434

版权

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

简单

给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。

差值是一个正数，其数值等于两值之差的绝对值。

递归

中序遍历二叉树，形成一个递增数组，求两个数最小差值

# 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
class Solution:
    vec = []# 类变量
    def traversal(self, root):
        if root is None:
            return
        # 中序遍历
        self.traversal(root.left)
        self.vec.append(root.val)
        self.traversal(root.right)

    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        self.vec = [] # 不清空的话 实例1的结果会一直在vec里 影响实例2
        min_num = inf
        self.traversal(root)
        for i in range(1,len(self.vec)):
            min_num = min(min_num, self.vec[i]-self.vec[i-1])
        return min_num

递归（不用数组）

⚠️ min_num 和pre都要被定义为实例变量

# 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
class Solution:
    min_num = inf
    pre = None # pre需要定义为实例变量，防止在每次递归都被置为none
    def reaversal(self, root):
        if root is None:
            return None
        self.reaversal(root.left)
        if self.pre is not None:
            self.min_num = min(self.min_num, root.val - self.pre.val)
        self.pre = root
        self.reaversal(root.right)

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

迭代

# 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
class Solution:
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        p =root
        st = []
        min_num = inf
        pre = -inf
        while p is not None or st:
            while p is not None:
                st.append(p)
                p = p.left
            p = st.pop()
            cur = p.val
            if cur - pre < min_num:
                min_num =cur - pre
            pre = cur
            p = p.right
        return min_num

501. 二叉搜索树中的众数

给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有众数（即，出现频率最高的元素）。

如果树中有不止一个众数，可以按 任意顺序 返回。

假定 BST 满足如下定义：

结点左子树中所含节点的值 小于等于 当前节点的值
结点右子树中所含节点的值 大于等于 当前节点的值
左子树和右子树都是二叉搜索树

普通二叉树情况

遍历二叉树（顺序无所谓），记录每个元素出现的次数

二叉搜索树

递归

实例变量：cnt（计数），maxcnt（记录众数出现次数），res（结果），pre（上一个节点）

空节点，return 无返回值

中序遍历，中的处理逻辑为：

如果pre为空（刚开始遍历），cnt置1
如果当前节点和pre相同，cnt+1
如果不相同，cnt置1，重新计数
如果cnt与maxcnt相等，说明出现多个众数，加进res
如果cnt大于maxcnt，出现遍历至今的真正众数，更新maxcnt值，并清空res，加入当前节点

# 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
class Solution:
    cnt = 0
    maxcnt = 0
    res = []
    pre = None
    def traversal(self, root):
        if root is None:
            return 
        # 左
        self.traversal(root.left)
        # 中
        if self.pre is  None: 
            self.cnt = 1 # 刚开始遍历第一个节点
        elif self.pre.val == root.val:
            self.cnt += 1
        else:
            self.cnt = 1
        self.pre = root
        if self.cnt == self.maxcnt:# 找到当前遍历中的众数
            self.res.append(root.val)
        elif self.cnt > self.maxcnt: # 更新众数
            self.maxcnt = self.cnt # 更新最大出现次数
            self.res = [root.val] # 清空原来的结果加入目前的众数
        # 右
        self.traversal(root.right)
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        #self.cnt = 0
        #self.maxcnt = 0
        #self.res = []
        #self.pre = None
        self.traversal(root)
        return self.res

迭代

# 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
class Solution:
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        p =root
        st = []
        cnt = 1
        max_num =1 
        ans = []
        pre = -inf
        while p is not None or st:
            while p is not None:
                st.append(p)
                p = p.left
            p = st.pop()
            cur = p.val #cur and pre都是值
            if cur == pre:
                cnt +=1
            else:
                cnt =1
                pre = cur
            if cnt == max_num:
                ans.append(cur)
            if cnt > max_num:
                max_num = cnt
                ans = [cur]
            p = p.right
        return ans

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

中等

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

思路：自底向上返回当前的这棵树是否有包含p、q的节点，如果这个节点含有p或q则返回当前这棵树的根节点

确定遍历顺序：自底而上：后序遍历（即回溯）因为只有处理了左右，然后根据左右的信息判断该不该返回当前这棵树的“根节点”(即中)

细节点：如果p和q包含在同一颗子树并且p或q是这颗子树的根节点这种情况实际已经包含在中逻辑的 10 或 01 的情况中因为一整个树肯定会有pq 说明不是左子树就是右子树

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

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if root is None or root is p or root is q:
            return root # 如果当前节点 root 为 None，则返回 None。
# 如果 root 是节点 p 或 q，则返回 root 自身。这是因为如果找到其中一个节点，就可以向上返回告诉上一个节点
# 后序遍历
        left = self.lowestCommonAncestor(root.left, p, q)
        right = self.lowestCommonAncestor(root.right, p ,q)
        # 中：left 和 right不为空的话，则当前节点就是公共祖先
        if left and right:
            return root
""" 
        # if left is None and right:
        #    return right
        # if right is None and left:
        #    return left
"""
        return left if left else right   
        # left 存储的是对左子树递归调用 lowestCommonAncestor 的结果。
        # 如果找到节点p或q，left 将指向找到的节点；如果没有找到，left 将为 None。