力扣刷题-python-二叉树-3（递归法、迭代法、二叉树恢复、二叉搜索树）

最新推荐文章于 2024-01-29 07:30:00 发布
最新推荐文章于 2024-01-29 07:30:00 发布
阅读量632 收藏
点赞数
分类专栏： python(力扣)-刷题笔记 文章标签： leetcode python 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/luxppp880/article/details/122059548
版权

文章目录

1.平衡二叉树

110. 平衡二叉树 - 力扣（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 isBalanced(self, root: TreeNode) -> bool:

        def getHeight(noder):
            if not noder :return 0
            
            leftHeight = getHeight(noder.left)  #左
            if leftHeight==-1: return -1
            rightHeight= getHeight(noder.right) #右
            if rightHeight==-1: return-1
            if abs(rightHeight-leftHeight)>1:result= -1  #中
            else:result= 1+max(rightHeight,leftHeight)
            return result
        
        return bool(getHeight(root)+1)

2.递归法

257. 二叉树的所有路径 - 力扣（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 binaryTreePaths(self, root: TreeNode) -> List[str]:
        res= []
        def getPath(root,pathls):
            if not root.left and not root.right:
                res.append(pathls+str(root.val))
                return
            pathls+=str(root.val)+'->' #中
            if root.left: getPath(root.left,pathls) #左 
            if root.right:getPath(root.right,pathls)#右 
        getPath(root,'')
        return res
'''
#迭代法
class Solution:
    """二叉树的所有路径 迭代法"""

    def binaryTreePaths(self, root: TreeNode) -> List[str]:
        # 题目中节点数至少为1
        stack, path_st, result = [root], [], []
        path_st.append(str(root.val))

        while stack:
            cur = stack.pop()
            path = path_st.pop()
            # 如果当前节点为叶子节点，添加路径到结果中
            if not cur.left and not cur.right:  result.append(path)
            if cur.right:
                stack.append(cur.right)                #无所谓左右 只要path_st能和stack对上就行
                path_st.append(path + '->' + str(cur.right.val)) #
            if cur.left:
                stack.append(cur.left)
                path_st.append(path + '->' + str(cur.left.val)) #
        return result

513. 找树左下角的值 - 力扣（LeetCode） (leetcode-cn.com)

class Solution:
    def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
            #递归法
            maxDepth= -1
            leftDepVal=0
            def recur(root,depther):
                nonlocal maxDepth, leftDepVal
                if not root.left and not root.right:
                    if maxDepth< depther:    #第一个出现的 比他大的 就是这层的最坐标
                        maxDepth = depther
                        leftDepVal= root.val
                if root.left: recur(root.left, depther+1)
                if root.right: recur(root.right,depther+1)
            recur(root,0)
            return leftDepVal

112. 路径总和 - 力扣（LeetCode） (leetcode-cn.com)

class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        def isornot(root,targetSum):
            if not root: return False
            targetSum-=root.val
            if not root.left and not root.right and not targetSum: return True
            return isornot(root.left,targetSum) or isornot(root.right,targetSum)
        return isornot(root,targetSum)

113. 路径总和 II - 力扣（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 pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        #递归
        res=[]
        def rec(root,targetSum,pather):
            if not root: return 
            targetSum-=root.val
            pather.append(root.val)
            if not root.left and not root.right and not targetSum:return res.append(pather)
            if root.left: rec(root.left,targetSum,pather[:])
            if root.right: rec(root.right,targetSum,pather[:])
            pather.pop()
        rec(root, targetSum, [])
        return res

617. 合并二叉树 - 力扣（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 mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode:
        #递归
        if not root1 and not root2 :return None
        elif not root1: return root2
        elif not root2: return root1
        
        root1.val+=root2.val
        root1.left = self.mergeTrees(root1.left,root2.left)
        root1.right= self.mergeTrees(root1.right,root2.right)
        return root1

3.迭代法

404. 左叶子之和 - 力扣（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 sumOfLeftLeaves(self, root: TreeNode) -> int:
        stack= [root]
        res=0
        while stack:
            noder = stack.pop()
            if not noder:
                noder = stack.pop()
                if not noder.left and not noder.right: res+=noder.val
            if noder.left:
                stack.append(noder.left)
                stack.append(None)           
            if noder.right:stack.append(noder.right) 
        return res

513. 找树左下角的值 - 力扣（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 findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        #最好是层序遍历 最底层最左边的点  用迭代
        queuer = deque([root])
        res=0
        while queuer:
            for _ in range(len(queuer)):
                    noder = queuer.popleft()
                    if not _:res= noder.val         #记录最后一行最左边数值
                    if noder.left: queuer.append(noder.left)
                    if noder.right:queuer.append(noder.right)
        return res

112. 路径总和 - 力扣（LeetCode） (leetcode-cn.com)

class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if not root: return False
        #层序遍历
        queue=deque([[root,targetSum]])
        while queue:      
            for _ in range(len(queue)):
                noder,pahtsum = queue.popleft()
                pahtsum-=noder.val
                if not noder.right and not noder.left and not pahtsum:return True
                if noder.left:queue.append([noder.left,pahtsum])
                if noder.right :queue.append([noder.right,pahtsum])
        return False

617. 合并二叉树 - 力扣（LeetCode） (leetcode-cn.com)

class Solution:
    def mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode:
        if not root1:return root2
        if not root2:return root1
        #将两个同时放到队列里面比较
        queue = deque([])
        queue.append(root1)
        queue.append(root2)
        while queue:
            noder1 = queue.popleft()
            noder2 = queue.popleft()
            noder1.val+= noder2.val
            #如果两棵树左右节点都不为空，加入队列
            if noder1.left and noder2.left:
                queue.append(noder1.left)
                queue.append(noder2.left)
            if noder1.right and noder2.right:
                queue.append(noder1.right)
                queue.append(noder2.right)
            #如果root1左或右为空 恰好root2 不为空    
            if not noder1.left and noder2.left: noder1.left = noder2.left
            if not noder1.right and noder2.right: noder1.right = noder2.right
        return root1

4.构造二叉树

106. 从中序与后序遍历序列构造二叉树 - 力扣（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 buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
         #用后序数组的最后一个 去切中序 前面为左边子节点 后面为右边子节点
        #def sbuildtree(inorder: List[int], postorder: List[int]):
        if not inorder:return None
        root = TreeNode(postorder[-1])
        inorindex = inorder.index(postorder[-1])
        inorder_left= inorder[:inorindex]  #必须用变量替换  重复选择 会
        postindex= len(inorder_left)
        root.left = self.buildTree(inorder_left,postorder[:postindex])
        root.right= self.buildTree(inorder[inorindex+1:],postorder[postindex:-1])
        return root

105. 从前序与中序遍历序列构造二叉树 - 力扣（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 buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        #前序 中左右 中序 左中右
        #前序第一个为 根节点 然后用他去切割中序 ，反过来切割前序，分成左右支 继续递归
        if not preorder:return None
        root = TreeNode(preorder[0])

        inoindex = inorder.index(preorder[0])
        leftInorder = inorder[:inoindex]
        preoindex = len(leftInorder)

        root.left = self.buildTree(preorder[1:preoindex+1],leftInorder)
        root.right= self.buildTree(preorder[preoindex+1:],inorder[inoindex+1:])
        return root

654. 最大二叉树 - 力扣（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 constructMaximumBinaryTree(self, nums: List[int]) -> TreeNode:
        #找到最大值，然后左右分两边 继续递归
        if not nums: return None

        maxval = max(nums)
        root = TreeNode(maxval)
        index = nums.index(maxval) 

        root.left = self.constructMaximumBinaryTree(nums[:index])
        root.right= self.constructMaximumBinaryTree(nums[index+1:])
        return root

5.二叉搜索树

700. 二叉搜索树中的搜索 - 力扣（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 searchBST(self, root: TreeNode, val: int) -> TreeNode:
        #层序搜索
        queue = deque([root])
        while queue:
            noder = queue.popleft()
            if noder.val== val: return noder
            elif val> noder.val:
                if noder.right:
                    queue.append(noder.right)
            else:
                if noder.left: 
                    queue.append(noder.left)
        return None
'''
'''
class Solution:
    def searchBST(self, root: TreeNode, val: int) -> TreeNode:
        while root!=None:
            if root.val> val : root= root.left
            elif root.val<val: root= root.right
            else:return root
        return None
'''
class Solution:
    #递归法
    def searchBST(self, root: TreeNode, val: int) -> TreeNode:
        if not root:return None
        if root.val>val: 
            return self.searchBST(root.left,val)
        elif root.val<val: 
            return self.searchBST(root.right,val)
        else:
            return root

6.总结

明天还有二叉树的最后一天，应该可以看完，就剩下二叉搜索树了。

Python递归和迭代器的练习
weixin_43236533的博客
02-21 755
学习网址 廖雪峰官方网站 递归函数 递归函数调用是通过栈这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。解决递归调用栈溢出的方法是通过尾递归优化。（尾递归优化:retrun只调用自身函数，不包含表达式） 遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的函数改成尾递归方式，也会导致栈溢出。 练习一：n的阶层 #方法一 def ClassN(n):
Leecode刷题记录（Python）（按代码随想录顺序）
weixin_44283270的博客
06-17 1414
时间O(n2)，空间O(1)
力扣刷题-python-二叉树-1（三种遍历方法 递归、 迭代 、全模板）
luxppp880的博客
12-19 1599
1.二叉树 二叉树分为满二叉树和完全二叉树 1）满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。 度为0说明孩子节点为0，度为2说明孩子节点为2 、 这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。 2）完全二叉树 完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^h -1 个节点。 3)
python练习——二叉树
u010744489的博客
06-01 320
二叉树练习——二叉树的中序遍历二叉树Leetcode二叉树的中序遍历 二叉树 二叉树结构是一个节点上最多有两个子树的树结构。定义二叉树是用指针来定义树中的每个节点，包括一个节点值、一个指向左子树的左指针和一个指向右子树的右指针。如图所示 代码如下所示 class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None 假如有一棵二叉树如下图所示
leetcode 关于二叉树的基本题上 python3题解
Luckycat0215的博客
09-08 207
1. 递归 我本来的思路就是递归。但是要注意root若为空返回空列表，不然就会产生AttributeError： # 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 clas
python对称二叉树
Anut_hey的博客
09-30 402
方法1：用层序遍历，一层层检测是否对称 方法2：递归或BFS，对应节点逐个比较，每次比较完一对节点(left,right)，新增两对需比较结点 (left.left,right.right),(left.right,right.left)，二叉树，倍增的思想 递归 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # se
leetcode答案-BrushQuestions:在力扣刷题的代码以及优秀答案参考,使用python语言
06-30
8. **递归与迭代**：在解题中，递归和迭代是常用的思维方式，尤其是在处理树结构和动态规划问题时。理解它们的区别和适用场景是提高解题能力的关键。 9. **动态规划**：这是一种强大的算法思想，常用于解决最优化...
力扣树专题-6 广度优先搜索 刷熟一个模板（层序遍历打印二叉树）秒杀一堆问题leetcode102 111 116 617 java刷题笔记
一碗菜粥的博客
06-13 2658
广度优先搜索算法BFS专题 根据一个模板 秒杀其他题目
【二叉树】二叉搜索（BST）树验证、二叉搜索树中的搜索、二叉搜索树的最小绝对差
CXY819394的博客
01-29 1659
🌟 二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树，它有一些独特的特性，非常适合用来存储数据并快速地进行查找、插入和删除操作。结构特点：每个节点有最多两个子节点，通常被称为“左子节点”和“右子节点”。排序规则每个节点的左子树只包含小于该节点的值。每个节点的右子树只包含大于该节点的值。没有两个节点拥有相同的值。查找效率：由于二叉搜索树的排序特性，查找效率通常比较高。在最理想的情况下（树是平衡的），查找操作的时间复杂度为O(log n)，其中n是树中节点的数量。
如何从下至上层次遍历二叉树？--二叉树遍历大法总结
zhangyixing1007_的博客
06-03 2217
文章将分为以下几个部分： 综述 前序遍历 后序遍历 中序遍历 层序遍历，从上至下 层序遍历，从下至上 关于栈，多说两句 欢迎star zhangyixing1007/leetcode，一起交流算法题。 1. 综述 （以下例子中的超链接都可点击） 遍历方式 递归 迭代 例子 前序遍历 三行 栈 lc144 中序遍历 三行 栈 lc145 后序遍历 三行 栈 lc094 ， lc098 层序遍历，从上至下 – 队列 lc102 层序遍历，从下至上 – 队列 – 说明：
python力扣刷题——翻转二叉树、对称二叉树（递归法、迭代法）
野猫炫的博客
11-09 1538
对于一棵对称二叉树的每一棵子树，以穿过根节点的直线为对称轴，左边子树的左节点=右边子树的右节点，左边子树的右节点=左边子树的左节点。每一棵大的二叉树都是由很多的子二叉树组成的。要求：从上到下打印二叉树，同层节点按照从左往右的顺序打印，即树的广度优先搜索（BFS）。运用队列结构的思想，将同一层的节点加到队列中，每次在结果集中追加同一层节点的val。左子树的左节点与右子树的右节点相等， 左子树的右节点与右子树的左节点相等。将左子树的左边和右子树的右边做为函数的输入，进行判断，不断递归。
不同的二叉搜索树Python解法
皮_客的博客
03-18 511
给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。 例： 输入：n = 3 输出：5 解析： 动态规划，n个节点，提取其中一个节点当根节点，因为每个节点的值不同，但是顺序不能打乱，所以一共可以构成（左子树个数）* （右子树个数），这就分成了子问题，符合动态规划，0个节点所能构成的树是0个但因为要进行乘法梳理，所以设置为1个，相乘起来并不影响，dp[0]=1，dp[1]=1。当有两个节点时，1节点和2节点都能当做根
力扣刷题-python-二叉树-2（层序遍历、混合遍历）
luxppp880的博客
12-20 849
1. 二叉树层序遍历 102. 二叉树的层序遍历 - 力扣（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
二叉树前中后序的非递归方法--迭代--Python
admin_lzq的博客
09-30 163
二叉树的遍历的先中后与层序遍历 递归方法 # 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 __init__(self):
二叉树 | 层序遍历 | leecode刷题笔记
qq_44250700的博客
08-10 1031
跟随carl代码随想录刷题 语言：python 👍carl哥太牛了！！！
Leetcode刷题（28）二叉树专题：树的前序遍历（三种方法：递归、迭代的两种写法）
Promise_Lv_2019的博客
06-18 427
本篇重要参考资料(点此跳转)。这篇解析，不仅简单介绍了二叉树这种数据结构，还详细罗列了各种不同遍历的方法，对于我使用的教材是个很好的补充。 # Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution: def
Python_迭代与递归_阶乘示例
liming_2464的博客
07-04 1309
迭代方法_求n的阶乘 def factorial(n): result = n for i in range(1, n): result *= i return result number = int(input("请输入一个正整数：")) result1 = factorial(number) print("%d的阶乘为：%d" % (number,re...
105. 从前序与中序遍历序列构造二叉树
七月听雪的博客
11-25 152
# Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution(object): ...
【重拾算法~Leetcode每日一题】95. 不同的二叉搜索树 II（难度：中等）
木土木土木土的日常
07-21 194
95. 不同的二叉搜索树 II 给定一个整数 n，生成所有由 1 … n 为节点所组成的 二叉搜索树 。 # 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 Solu
力扣100答案及思路
最新发布
03-28
1. **递归法** 递归是最直观的解法，核心思想是逐层比较两棵树的节点： - **终止条件**： - 若两节点均为空，返回 `True` - 若一个为空而另一个非空，返回 `False` - **当前层逻辑**： - 比较两节点值...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值