代码随想录算法训练营第十六天

104. 二叉树的最大深度

递归实现

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        def getDepth(node):
            if node is None:return 0
            else:
                leftDepth = getDepth(node.left)
                rightDepth = getDepth(node.right)
                height = max(leftDepth,rightDepth)+1  
            return height      
        return getDepth(root)

##精简版
    def maxdepth1(self, root: treenode) -> int:
        if not root:
            return 0
        return 1 + max(self.maxdepth(root.left), self.maxdepth(root.right))

递归三要素：

确定递归参数和返回值

确定递归终止条件

确定单层递归的逻辑

层序遍历迭代法

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if root is None:return 0
        queue = deque([root])
        count = 0
        while queue:
            count+=1
            for _ in range(len(queue)):
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return count

559. N 叉树的最大深度

递归实现

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

层序遍历迭代法

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        
        depth = 0
        queue = collections.deque([root])
        
        while queue:
            depth += 1
            for _ in range(len(queue)):
                node = queue.popleft()
                for child in node.children:
                    queue.append(child)
        
        return depth

111. 二叉树的最小深度

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        depth = 0
        queue = deque()       
        queue.append(root) 
        while queue:
            depth += 1 
            for _ in range(len(queue)):
                node = queue.popleft()                
                if not node.left and not node.right:
                    return depth           
                if node.left:
                    queue.append(node.left)                   
                if node.right:
                    queue.append(node.right)
        return depth

class Solution:
    def minDepth(self, root):
        if root is None:
            return 0
        if root.left is None and root.right is not None:
            return 1 + self.minDepth(root.right)
        if root.left is not None and root.right is None:
            return 1 + self.minDepth(root.left)
        return 1 + min(self.minDepth(root.left), self.minDepth(root.right))

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

class Solution:
    def countNodes(self, root: TreeNode) -> int:
        if root is None:return 0 
        queue = deque([root])
        result = 0
        while queue:
            for i in range(len(queue)):
                node = queue.popleft()
                result += 1 
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return result


    def countNodes1(self, root: Optional[TreeNode]) -> int:
        if root is None:
            return 0
        return 1+self.countNodes(root.left)+self.countNodes(root.right)


    def countNodes2(self, root: Optional[TreeNode]) -> int:
        def count1(node):
            if node is None:
                return 0
            return count1(node.left)+count1(node.right)+1
        return count1(root)

二叉树构建及输入输出

class TreeNode(object):
    def __init__(self, val=0):
        self.val = val
        self.left = None
        self.right = None


def create_tree(input):
    if len(input) == 0 or input is None:
        return None
    data = input.pop(0)
    if data is None:
        return None
    node = TreeNode(data)
    node.left = create_tree(input)
    node.right = create_tree(input)
    return node


input_list = [1, 2, 3, None, None, 4, None, None, 5, None, 6]
root = create_tree(input_list)