算法记录 | Day16 二叉树

• 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
• 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数后者节点数（取决于高度从0开始还是从1开始）

    		   深度   高度
    3			1	  3
   / \
  9  20			2	  2
    /  \
   15   7		3     1
			   前序   后序

深度：从上往下看

高度：从下往上看，从下往上计数

104.二叉树的最大深度

递归法

思路：

1.确定递归参数和返回值：输入node，输出d

2.终止条件：遇到None，return 0

3.单层逻辑：后序遍历，左边深度，右边深度，中间 = 1+max(左深度，右深度 )

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        return self.getdepth(root)

    def getdepth(self,root):
        if not root:
            return 0
        leftdepth = self.getdepth(root.left)
        rightdepth = self.getdepth(root.right)
        depth = 1 + max(leftdepth,rightdepth)
        return depth

精简后代码

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
   		return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1

迭代法

思路：层序遍历，每层增加1

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        results = 0
        que = [root]
        if not root:
            return results
        while que:
            size = len(que)
            results +=1
            for i in range(size):
                cur = que.pop(0)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
        return results

559. N 叉树的最大深度

递归法

思路：

1.确定递归参数和返回值：输入node，输出d

2.终止条件：遇到None，return 0

3.单层逻辑：每个子节点 深度 ，根节点选取max(childepth)+1

class Solution:
    def maxDepth(self, root: 'Node') -> int:
        if not root:
            return 0
        maxDepth = 0
        for child in root.children:
            childepth = self.maxDepth(child)
            maxDepth = max(maxDepth,childepth)
        return maxDepth+1

迭代法

class Solution:
    def maxDepth(self, root: 'Node') -> int:
        if not root:
            return 0
        result = 0
        que = [root]
        while que:
            size = len(que)
            for _ in range(size):
                cur = que.pop(0)
                for child in cur.children:
                    que.append(child)
            result+=1
        return result

111.二叉树的最小深度

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

    			   高度
    3				3
   / \
null  20			2
     /   
    15   7			1
        /  \
       10   8
根节点3到最近叶子节点15的深度：3，而不是到null

递归法

思路：

1.确定递归参数和返回值：输入root，输出h

2.终止条件：遇到None，return 0

3.单层逻辑：左深度，右深度，避免出现上述null情况增加判断，同时为空return 1，左边不空取最小，右边不空取最小，返回最小+1

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        if not root.left and not root.right:
            return 1

        lefth = self.minDepth(root.left)
        righth = self.minDepth(root.right)
        minh = 0xffffff
        if root.left:
            minh = min(minh,lefth)
        if root.right:
            minh = min(minh,righth)
        return minh + 1

迭代法

思路：

1.当左右孩子都为空的时候，才说明遍历到最低点了。如果其中一个孩子不为空则不是最低点

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        que = [root]
        result = 1
        while que:
            size = len(que)
            for i in range(size):
                cur = que.pop(0)
                if not cur.left and not cur.right:
                    return result
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            result +=1
        return result
            

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

递归法

思路：

1.确定递归参数和返回值：输入root，输出节点数

2.终止条件：遇到None，return 0

3.单层逻辑：左边节点数，右边节点数，中间 = 左边数+右边数+1

class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        return self.getNodesNum(root)

    def getNodesNum(self,root):
        if not root:
            return 0
        leftNums = self.getNodesNum(root.left)
        rightNums = self.getNodesNum(root.right)
        nodesNum = leftNums + rightNums + 1
        return nodesNum

迭代法

class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        result = 0
        que = [root]
        while que:
            size = len(que)
            for  i in range(size):
                cur =  que.pop(0)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            result+=size
        return result