二叉树深度/结点/高度/路径/回溯/左子树之和/左下角的值

已于 2022-05-01 01:50:40 修改
阅读量786 收藏
点赞数
分类专栏： 算法复习 文章标签： 数据结构 算法 python
于 2022-04-25 23:00:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sueong/article/details/124286386
版权

104.二叉树的最大深度

在这里插入图片描述

递归后序

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        def getDepth(root):
            if not root:
                return 0 
            depth = 0
            leftdepth = getDepth(root.left)# 左
            rightdepth = getDepth(root.right)# 右
            depth = max(leftdepth, rightdepth) + 1# 中 算上本层的结点 所以加1
            return depth
        
        if not root:
            return 0
        d =getDepth(root)
        return d

迭代法

 # 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 maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        
        que = deque([root])
        k = 0 # 记录遍历的层数 
        while que:
            r = []
            size = len(que)
            for i in range(size):
                cur = que.popleft()
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            k+=1
        return k

559.n叉树的最大深度

在这里插入图片描述

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution:
    def maxDepth(self, root: 'Node') -> int:
        def getDepth(root):
            if not root:
                return 0
            depth = 0
            # 参考后序左右中 所以n叉树 孩子遍历也是左右中 同时每次与上一次的
            for child in root.children:
                depth = max(depth,getDepth(child))
            
            depth += 1 # 中
            return depth
        
        if not root:
                return 0
        d = getDepth(root)
        return d

迭代法

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: Node
        :rtype: int
        """

        if not root:
            return 0
        que = deque([root])
        d = 0
        while que:
            size = len(que)
            d+=1
            for _ in range(size):
                cur = que.popleft()
                if  cur.children:# 孩子不空
                    que.extend(cur.children)
          
        return d

111.二叉树的最小深度

在这里插入图片描述
在这里插入图片描述
递归

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        def getDepth(root):
            if not root:
                return 0
            leftdepth = getDepth(root.left)
            rightdepth = getDepth(root.right)
            #左孩空 右不为空，这时并不是最低点
            if not root.left and root.right:
                return rightdepth + 1
            # 右孩空 左不为空，这时并不是最低点
            elif root.left and not root.right:
                return leftdepth + 1
            
            depth = 1 + min(leftdepth,rightdepth)
            return depth
        
        if not root:
            return 0
        return getDepth(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:
    def minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0

        k = 1 # 根节点深度1
        que = deque([(root,1)])
        while que:
            size = len(que)
            for i in range(size):
                cur,k = que.popleft()
                # 假设是根节点 左右孩子都空 则返回k
                if cur.left == None and cur.right == None:
                    return k 
                # 因为在一个for循环内 有左还右孩子 层数都加1 
                if cur.left:
                    que.append((cur.left,k+1))
                if cur.right:
                    que.append((cur.right,k+1))

        return 0

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        que = deque()
        que.append(root)
        res = 1

        while que:
            for _ in range(len(que)):
                node = que.popleft()
                # 当左右孩子都为空的时候，说明是最低点的一层了，退出
                if not node.left and not node.right:
                    return res
                if node.left is not None:
                    que.append(node.left)
                if node.right is not None:
                    que.append(node.right)
            res += 1
        return res

222. 完全二叉树的节点个数

迭代法

# 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 countNodes(self, root: TreeNode) -> int:
        if not root:
            return 0
        num = 0
        que = deque([root])
        while que:
            size = len(que)
            for _ in range (size):
                num += 1
                cur = que.popleft()
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
        return num

递归法

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def countNodes(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        def getNode(root):
            if not root:
                return 0
            leftnum = getNode(root.left) # 左
            rightnum = getNode(root.right) # 右
            num = leftnum + rightnum + 1 #中
            return num
        
        return getNode(root)

110.平衡二叉树

二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数。（往下数在第几层）
二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数（往上数在第几层）

因为求深度可以从上到下去查 所以需要前序遍历（中左右），而高度只能从下到上去查，所以只能后序遍历（左右中）
在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if self.getHeight(root) != -1:
            return True
        else:
            return False

    def getHeight(self, root):
        if not root: # 为空 高度0
            return 0

        lh = self.getHeight(root.left)# 左
        if lh == -1:
            return -1

        rh = self.getHeight(root.right)# 右
        if rh == -1:
            return -1
        
        if abs(lh - rh) > 1:#中
            return -1
        
        # 以当前节点为根节点的树的最大高度 因为需要算上当前结点的高度
        else:
            return 1 + max(lh, rh)

257. 二叉树的所有路径

在这里插入图片描述

注：回溯和递归是一一对应的，有一个递归，就要有一个回溯
在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def binaryTreePaths(self, root):
        """
        :type root: TreeNode
        :rtype: List[str]
        """
        if not root:
            return[]
        res = []
        self.getPath(root,'', res)
        return res


    def getPath(self, root, path, res):
        if not root:
            return
        
        path += str(root.val) #中
        # 处理单层逻辑 如果到叶子节点  加入列表中
        if not root.left and not root.right:
            res.append(path)
        
        else:
            path += '->'
            self.getPath(root.left, path, res)#左
            self.getPath(root.right, path, res)#右

404. 左叶子之和

在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def sumOfLeftLeaves(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        # 边界
        if not root:
            return 0
        
        cur_val = 0
        left_sum = self.sumOfLeftLeaves(root.left)# 左
        right_sum = self.sumOfLeftLeaves(root.right)# 右
        # 中 处理单层逻辑 判断是不是左叶子 首先是左然后是叶子 
        if root.left != None and root.left.left == None and root.left.right == None:
            cur_val = root.left.val
        
        return cur_val + left_sum + right_sum

513.找树左下角的值

思路：层序遍历 在树的最后一行找到最左边的值。
在这里插入图片描述

sueong
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode刷题：Tree专题
qq_35565669的博客
04-04 508
112.Path Sum class Solution(object): def hasPathSum(self, root, sum): """ :type root: TreeNode :type sum: int :rtype: bool """ de...
Leetcode刷题(25) 树的问题
lzAllen的博客
08-30 153
Leetcode刷题(25) 树的问题 剑指 Offer 68 - II. 二叉树的最近公共祖先 # 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): def l
【Leetcode】二叉树篇（三）
Quanquanxiannv的博客
08-04 96
二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数。 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数。 递归三部曲 确定递归函数的参数和返回类型 如果需要搜索整颗二叉树，那么递归函数就不要返回值， 如果要搜索其中一条符合条件的路径，递归函数就需要返回值， 因为遇到符合条件的路径了就要及时返回。 确定终止条件 确定单层递归的逻辑 404. 左叶子之和 计算给定二叉树的所有左叶子之和。 class Solution { public int sumOfLeft.
二叉树的构建
li123128的博客
11-10 3275
二叉树是一种非常重要的数据结构。本文总结了二叉树的常见操作：二叉树的构建，查找，删除，二叉树的遍历(包括前序遍历、中序遍历、后序遍历、层次遍历)，二叉搜索树的构造等。
LeetCode 112 路径总和 NC9 二叉树中和为某一值的路径(一)
麦格芬230的博客
01-29 129
给定一个 n×n 的二维矩阵matrix 表示一个图像。请你将图像顺时针旋转 90 度。 你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。 示例 1： 输入：matrix = [[1,2,3],[4,5,6],[7,8,9]] 输出：[[7,4,1],[8,5,2],[9,6,3]] 示例 2： 输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]] 输出：[[.....
嵌入式系统/ARM技术中的关于二叉树的遍历
11-10
在嵌入式系统和ARM技术领域，数据结构的掌握至关重要，特别是二叉树这一概念，因为它们在存储和处理数据时发挥着基础性作用。二叉树遍历是理解和操作二叉树的关键技术，它涉及沿着特定顺序访问二叉树的所有节点，...
c/c++二叉树详解，作业，学习参考
12-04
1. **AVL树**：AVL树是一种自平衡的二叉搜索树，其特点是任意节点的两个子树的高度差不超过1，从而保证了插入和删除操作的时间复杂度为O(logn)。AVL树通过旋转操作（左旋、右旋）保持平衡，确保高效性。 2. **Treap...
深搜与回溯.zip_文章/文档_C/C++_
08-10
在计算机科学中，数据结构与算法是编程的基础，而深度搜索（Deep Search）和回溯算法是解决复杂问题的重要策略。本篇文章将详细探讨这两个概念，以及如何在C/C++语言环境下进行实现。 **一、深度搜索（Deep Search...
二叉树建立.rar_C#编程_C/C++_
08-09
3. 平衡二叉树：左右子树的高度差不超过1，并且左右子树都是平衡二叉树，如AVL树和红黑树。 二叉树的操作主要包括插入节点、删除节点、遍历（前序、中序、后序）和查找。在C#或C/C++中实现这些操作时，我们需要定义...
Binary-Tree.rar_数据结构_C/C++_
08-11
这个过程包括比较根节点的值，然后递归地比较各自的左子树和右子树。如果在任何时候发现节点值不同或子树结构不同，就可立即断定两棵树不相等。 在C语言中实现这些算法，通常需要定义一个二叉树节点结构体，如`...
【二叉树】【回溯】二叉树的所有路径详解【力扣.257】超详细的宝藏教程
后端开发为主+人工智能
03-05 2123
【二叉树】【回溯】二叉树的所有路径详解【力扣.257】超详细的宝藏教程 干货满满，不收藏绝对后悔！
二叉树的高度、深度、层数、路径长度
热门推荐
Acettest's Blogs
03-21 2万+
深度：对于任意节点n,n的深度为从根到n的唯一路径长，根的深度为0； 高度：对于任意节点n,n的高度为从n到一片树叶的最长路径长，所有树叶的高度为0； 所以对于一个有12个结点的完全二叉树，其所有结点的高度和为10 ...
二叉树：以为使用了递归，其实还隐藏着回溯
代码随想录
10-19 310
补充一波
class node python_请问我的python AVL树这样号写对不对，,class Node(o
weixin_31188807的博客
01-14 462
请问我的python AVL树这样号写对不对，,class Node(oclass Node(object): def __init__(self,key): self.key=key self.left=None self.right=None self.height=0class AVLTree(object): def __...
二叉树：递归函数什么时候需要返回值？
cckluv的博客
01-21 1224
二叉树：递归函数什么时候需要返回值？ 700. 二叉搜索树中的搜索 当初学数据结构的时候也弄不清楚，今天看到一句话很好的解释了： 「如果需要搜索整颗二叉树，那么递归函数就不要返回值，如果要搜索其中一条符合条件的路径，递归函数就需要返回值，因为遇到符合条件的路径了就要及时返回。」 比如： 他并非要遍历全部的二叉树，而是遍历到2就返回了，并非遍历到了全部二叉树. 因此，代码如下 class Solution { public: TreeNode* searchBST(TreeNode* root, i
二叉树递归算法理解_彻底理解二叉树的非递归遍历
weixin_29577659的博客
01-27 2257
印度尼西亚中部的苏拉威西岛遍历二叉树本质上和走迷宫一样，都是系统性搜索什么是二叉树在计算机科学中二叉树，binary tree，是一种数据结构，在该数据结构中每个节点最多有两个子节点，如图所示：二叉树的定义就是这样简单，但这种看起来很简单的数据结构遍历起来一点都不简单。如何遍历二叉树所谓遍历简单的讲就好比在迷宫中寻宝，宝物就藏在某一个树节点当中，但我们并不知道具体在哪个节点上，因此要找到...
LeetCode，二叉树的层次遍历、逆转
qq_45031079的博客
06-02 330
LeetCode，二叉树层次遍历（循环）、逆二叉树（递归）
617. 合并二叉树(Java)
Mrrr_Li的博客
11-14 99
class Solution { public TreeNode mergeTrees(TreeNode t1, TreeNode t2) { //如果 t1和t2中，只要有一个是null，函数就直接返回 if(t1==null || t2==null) { return t1==null? t2 : t1; } LinkedList<TreeNode> queue = new LinkedList<TreeNode>(); queue.add(t1); .
二叉树：dfs+回溯
ZJH
09-07 345
想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。这个题如果是用前序遍历（DFS）先存储结果到list中，空间复杂度为O(n)，还有一种方法不用DFS空间复杂度为O(1)这三种遍历其实都是dfs，只是递归的位置不同，一般二叉树用到dfs的都是这种区别（递归在前还是再后）注意: 合并过程必须从两个树的根节点开始。返回合并后的二叉树。
求二叉树中的（叶子/单分支/双分支）结点个数
最新发布
06-10
二叉树是由结点（Node）组成的，每个结点最多有两个子节点（左子节点和右子节点）。根据子节点个数的不同，可以将二叉树的结点分为三类：叶子结点、单分支结点和双分支结点。 - 叶子结点：没有子节点的结点称为叶子...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值