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

已于 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
    评论
专栏目录
嵌入式系统/ARM技术中的关于二叉树的遍历
11-10
在嵌入式系统和ARM技术领域，数据结构的掌握至关重要，特别是二叉树这一概念，因为它们在存储和处理数据时发挥着基础性作用。二叉树遍历是理解和操作二叉树的关键技术，它涉及沿着特定顺序访问二叉树的所有节点，...
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 154
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 130
给定一个 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]] 输出：[[.....
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）组成的，每个结点最多有两个子节点（左子节点和右子节点）。根据子节点个数的不同，可以将二叉树的结点分为三类：叶子结点、单分支结点和双分支结点。 - 叶子结点：没有子节点的结点称为叶子结点，也称为终端结点。叶子结点是二叉树的最底层结点，它们没有子节点，只有父节点。叶子结点的个数就是二叉树的度为0的结点个数。 - 单分支结点：只有一个子节点的结点称为单分支结点，也称为度为1的结点。单分支结点的个数就是二叉树的度为1的结点个数。 - 双分支结点：同时拥有左右两个子节点的结点称为双分支结点，也称为度为2的结点。双分支结点的个数就是二叉树的度为2的结点个数。 需要注意的是，一个二叉树的总结点个数等于叶子结点个数加上单分支结点个数加上双分支结点个数。 希望这个回答能够帮到你！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值