常见算法的进阶打怪路程|二叉树 06

最新推荐文章于 2024-10-16 19:08:56 发布

臭nian

最新推荐文章于 2024-10-16 19:08:56 发布

阅读量207

点赞数 1

分类专栏：常见算法的进阶打怪路程文章标签：算法

本文链接：https://blog.csdn.net/Neptune_keke/article/details/142267521

版权

常见算法的进阶打怪路程专栏收录该内容

18 篇文章 0 订阅

订阅专栏

530. 二叉搜索树的最小绝对差 - 力扣（LeetCode）

# 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 find(self,node):
        if not node:
            return []
        lf=self.find(node.left)
        rg=self.find(node.right)
        return lf+[node.val]+rg

    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        ree=float('inf')
        if not root:
            return 0
        re=self.find(root)
        for i in range(1,len(re)):
            ree=min(ree,re[i]-re[i-1])
        return ree

##双指针法
# 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 find(self, node):
        if not node:
            return self.re
        lf = self.find(node.left)

        if self.pre:
            self.re=min(self.re,abs(node.val-self.pre.val))
        self.pre = node

        rg = self.find(node.right)
        return self.re

    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        self.pre = None
        self.re=float('inf')
        return self.find(root)

501. 二叉搜索树中的众数 - 力扣（LeetCode）

# 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 find(self,node):
        if not node:
            return self.re

        self.find(node.left)

        if not self.pre:
            self.count=1
        else:
            if self.pre.val==node.val:
                self.count+=1
            else:
                self.count=1
        
        self.pre=node

        if self.count==self.max:
            self.re.append(node.val)
        if self.count>self.max:
            self.re=[node.val]
            self.max=self.count
            
        self.find(node.right)
            

        return self.re

    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        self.re=[]
        self.count=1
        self.max=0
        self.pre=None
        return self.find(root)

236. 二叉树的最近公共祖先 - 力扣（LeetCode）

# 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 not root or root==p or root==q:
            return root

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