力扣刷题-python-二叉树-4（二叉搜索树、查找、插值、删除、修改）

最新推荐文章于 2024-05-01 16:18:57 发布

朗风风

最新推荐文章于 2024-05-01 16:18:57 发布

阅读量535

点赞数

分类专栏： python(力扣)-刷题笔记文章标签： leetcode python 算法

本文链接：https://blog.csdn.net/luxppp880/article/details/122082601

版权

python(力扣)-刷题笔记专栏收录该内容

17 篇文章 9 订阅

订阅专栏

文章目录

1.验证二叉搜索树

98. 验证二叉搜索树 - 力扣（LeetCode） (leetcode-cn.com)
用了递归法和迭代法

# 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 isValidBST(self, root: TreeNode) -> bool:
        #规律: BST的中序遍历节点数值是从小到大
        maxval = -float("inf")
        def _isValidBST(root: TreeNode)->bool:
            nonlocal maxval
            if not root:return True
            #左中右 中序
            leftbool= _isValidBST(root.left)
            if root.val > maxval :maxval=root.val
            else:return False
            rightbool= _isValidBST(root.right)

            return leftbool and rightbool
        return _isValidBST(root)
'''
class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        #中序将所有数 读出来
        stacker = [root]
        leftres= -float("inf")
        while stacker:
            noder= stacker.pop()
            if noder:  #因为是栈 所以用左中右的倒序
                 if noder.right:stacker.append(noder.right)
                 stacker.append(noder)
                 stacker.append(None)
                 if noder.left:stacker.append(noder.left)
            else:
                noder= stacker.pop()
                if leftres>=noder.val:return False
                else:leftres = noder.val
        return True

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

530. 二叉搜索树的最小绝对差 - 力扣（LeetCode） (leetcode-cn.com)

# 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: TreeNode) -> int:
        leftval=-float(inf) #定义一个左边值  递归法
        def _getMinimumDifference(root: TreeNode):
            #中序搜索
            nonlocal leftval
            if not root:return float(inf)
            leftm= _getMinimumDifference(root.left)
            res = root.val-leftval
            leftval = root.val
            righm= _getMinimumDifference(root.right)
            return min(leftm,res,righm)
        return _getMinimumDifference(root)
'''
class Solution:
    def getMinimumDifference(self, root: TreeNode) -> int:
         stacker = [root]
         leftval =-float(inf)
         minval= float(inf)
         while stacker:
             noder= stacker.pop()
             if noder:
                 if noder.right: stacker.append(noder.right)
                 stacker.append(noder)
                 stacker.append(None)
                 if noder.left:  stacker.append(noder.left)
             else:
                 noder = stacker.pop()
                 minval = min(noder.val-leftval, minval)
                 leftval = noder.val
         return minval

501. 二叉搜索树中的众数 - 力扣（LeetCode） (leetcode-cn.com)

# 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: TreeNode) -> List[int]:
        leftval = None
        maxcount= 1
        stacker = [root]
        res=[]
        counter=1
        while stacker:
            noder= stacker.pop()
            if noder:
                if noder.right:stacker.append(noder.right)
                stacker.append(noder)
                stacker.append(None)
                if noder.left: stacker.append(noder.left)
            else:
                noder = stacker.pop()
                if leftval!= noder.val:
                    if counter>maxcount:
                        res=[leftval]
                        maxcount= counter
                    elif counter ==maxcount and leftval: res.append(leftval)
                    leftval =noder.val
                    counter=1
                else:
                    counter+=1
        if counter> maxcount: res=[noder.val]         #补上结尾的
        elif counter== maxcount:res.append(noder.val)
        return  res

235. 二叉搜索树的最近公共祖先 - 力扣（LeetCode） (leetcode-cn.com)
比236简单多了，因为二叉搜索树自带方向，遇见二叉搜索树可以尝试用这个性质。

# 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':
        '''
        #从上到下遍历 数值包含在pq 之间 说明为最近公共祖先
        #也就是层序遍历 再加判断
        if p.val>q.val:p,q=q,p #如果不是前大后小 交换
        queue = deque([root])
        while queue:
            noder = queue.popleft()
            if p.val<=noder.val<=q.val: return noder
            if noder.left:queue.append(noder.left)
            if noder.right:queue.append(noder.right)
        '''
        '''
        #用到二叉搜索树的特点 不在之间就是偏向于一边  再根据偏向的方向 迭代
        while 1:
            if   root.val>p.val and root.val>q.val: root= root.left
            elif root.val<q.val and root.val <p.val: root =root.right
            else:return root
        '''
        #同理可以用递归法
        if root.val>p.val and root.val>q.val: return self.lowestCommonAncestor(root.left,p,q)
        if root.val<q.val and root.val <p.val:return self.lowestCommonAncestor(root.right,p,q)
        return root

3.二叉搜索树的插入和删除

701. 二叉搜索树中的插入操作 - 力扣（LeetCode） (leetcode-cn.com)

# 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 insertIntoBST(self, root: TreeNode, val: int) -> TreeNode:
        insetval = TreeNode(val)
        if not root:return insetval
        rootls = root
        while 1:
            if val>rootls.val: 
                if rootls.right:
                    rootls= rootls.right
                else:
                    rootls.right=insetval
                    break
            else: 
                if rootls.left: 
                    rootls= rootls.left
                else:
                    rootls.left=insetval
                    break
        return root
'''
class Solution:
    def insertIntoBST(self, root: TreeNode, val: int) -> TreeNode:
        if not root: return TreeNode(val)  #递归的终止
        if root.val>val: root.left= self.insertIntoBST(root.left,val)
        if root.val<val: root.right=self.insertIntoBST(root.right,val)
        return root

450. 删除二叉搜索树中的节点 - 力扣（LeetCode） (leetcode-cn.com)
删除要比添加难，因为删除时候还要考虑双孩子都在情况具体是给那个
如下面删除7情况就是特殊情况之一，也是最难的一种情况，需要将左孩子节点放到右孩子节点最底层的左孩孩孩子节点下面

# 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 deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
        if not root:return root    #第一种情况  没有找到 返回空节点
        if not root.val-key:  
            if not root.left and not root.right:return None  #第二种情况 两孩子节点都为空 直接返回none
            if not root.left and     root.right:return root.right  #第三种情况 右孩子不为空 返回有孩子节点
            if     root.left and not root.right:return root.left   #第四种情况 左孩子不为空 同上情况
            else:#第五种情况：左右孩子节点都不为空，则将删除节点的左子树放到删除节点的右子树的最左面节点的左孩子的位置
                noder = root.right
                while noder.left: noder = noder.left
                noder.left = root.left
                return root.right
        if root.val>key:root.left = self.deleteNode(root.left,key)  #如果key 比root的值小，说明这个值在右孩子节点
        if root.val<key:root.right= self.deleteNode(root.right,key)
        return root

4.将有序数组恢复成二叉搜索树

108. 将有序数组转换为二叉搜索树 - 力扣（LeetCode） (leetcode-cn.com)

# 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 sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        if not nums:return None
        centIndex= len(nums)//2
        root = TreeNode(nums[centIndex])

        root.left = self.sortedArrayToBST(nums[:centIndex])     #前半拉是左孩子
        root.right= self.sortedArrayToBST(nums[centIndex+1:])   
        return root

5.二叉树值的修改

538. 把二叉搜索树转换为累加树 - 力扣（LeetCode） (leetcode-cn.com)
可以用倒中序右中左遍历的同时将值加上去

# 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 convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        #试下中序的倒序  右中左
        if not root: return root
        stacker = [root]
        sumVal=0
        while stacker:
            noder= stacker.pop()
            if noder:
                if noder.left: stacker.append(noder.left)
                stacker.append(noder)
                stacker.append(None)
                if noder.right: stacker.append(noder.right)
            else:
                noder = stacker.pop()
                sumVal+=noder.val
                noder.val= sumVal
        return root

6.总结

二叉树终于完成了，总共花费了4天时间，基本都可以用递归和迭代两种方法解决，但是针对于题，要偏向于某一种相对较容易解决。这里做个标记防止以后自己回来看，层序的要用队列，前中后序的要用栈。

朗风风

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
力扣刷题-python-二叉树-4（二叉搜索树、查找、插值、删除、修改）

1.验证二叉搜索树98. 验证二叉搜索树 - 力扣（LeetCode） (leetcode-cn.com)用了递归法和迭代法# 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
复制链接

扫一扫