【代码随想录】【二叉树】day16！递归递归递归！二叉树最大深度、最小深度、完全二叉树的节点个数

D_klein

已于 2024-03-08 21:30:44 修改

阅读量365

点赞数 9

文章标签：算法数据结构 python

于 2024-03-07 17:43:34 首次发布

本文链接：https://blog.csdn.net/weixin_45929355/article/details/136537545

版权

二叉树最大深度

递归方法

传的参数是根节点，根节点的高度就是二叉树的深度
后序遍历左右中的顺序，把处理逻辑即中的位置放到最后

class solution:
    # 最大深度
    def gethigh(self,root:TreeNode)->int:  # 传的参数是根节点，根节点的高度就是二叉树的深度
        # 后序遍历 左右中的顺序，把处理逻辑 即中的位置放到最后，
        if root is None:
            return 0
        left=self.gethigh(root.left)
        right=self.gethigh(root.right)
        high=1+max(left,right)

        return high

层序遍历解法

   def maxdepth(self,root:TreeNode):
        if root is None:return[]
        depth=0
        que=deque()
        que.append(root)
        while len(que)>0:
            depth+=1
            size=len(que)
            while size:
                root=que.popleft()
                size-=1
                if root.left:que.append(root.left)
                if root.right:que.append(root.right)
        return depth

二叉树最小深度

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

！！！！不能直接将gethigh函数的max直接改成min，如果根本没有左子树，那返回的最小深度是0，而不是叶子结点到根节点的节点数量。

在这里插入图片描述

 def gethighmin(self,root)->int: #
        # 后序遍历，左右中，获取左右节点的最小深度，依次向上传递给中间的根节点，得到根节点的最小深度
        if root is None:
            return 0
        left=self.gethighmax(root.left)
        right = self.gethighmax(root.right)
        
        if root.left==None and root.right!=None:
            return 1+right
        
        elif root.right==None and root.left!=None:
            return 1+left
            
        else:
            return 1+min(left,right)

完全二叉树的个数

借助完全二叉树的性质，如果一个节点的子树是一个满二叉树，则该子树的所有节点数量就是2^k-1。
这样就不用遍历所有节点。
【！！那么如何判断一个二叉树是满二叉树】：从根节点开始，向左遍历的次数和向右遍历的次数相等，那么二叉树是满的，可以直接返回节点给根节点

 def numsnodes2(self,root:TreeNode)->int:

        # 终止条件有两个
        #1
        if root is None:
            return 0
        #2
        left=root.left
        leftdepth=0
        right=root.right
        rightdepth=0
        while left:
            left=left.left
            leftdepth+=1

        while right:
            right=right.rigth
            rightdepth+=1

        if leftdepth==rightdepth:
            return 2**(leftdepth)-1
        # 单层递归的逻辑  后序遍历
        leftnums=self.numsnodes2(root.left)
        rightnums=self.numsnodes2(root.right)

        return leftnums+rightnums+1