常见算法的进阶打怪路程|二叉树 02

226. 翻转二叉树 - 力扣（LeetCode）

#迭代
# 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 invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        stack=[]
        if root:
            stack.append(root)
        while stack:
            node=stack[-1]
            if node:
                node=stack.pop()
                node.left,node.right=node.right,node.left
                if node.left:
                    stack.append(node.left)
                if node.right:
                    stack.append(node.right)
        return root
#递归
class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return root
        root.left,root.right=root.right,root.left
        root.left=self.invertTree(root.left)
        root.right=self.invertTree(root.right)
        return root

101. 对称二叉树 - 力扣（LeetCode）

##递归
# 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 compare(self,lf,rg):
        if not lf and not rg:
            return True
        elif not lf and rg:
            return False
        elif not rg and lf:
            return False
        elif rg.val!=lf.val:
            return False
        outside=self.compare(lf.left,rg.right)
        inside=self.compare(lf.right,rg.left)
        return inside and outside
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        lf=root.left
        rg=root.right
        return self.compare(lf,rg)

##迭代
# 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
from collections import deque
class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        que=deque()
        if not root:
            return True
        que.append(root.left)
        que.append(root.right)
        while que:
            lf=que.popleft()
            rg=que.popleft()
            if not lf and not rg:
                continue
            if (not lf and rg) or (not rg and lf) or (rg.val!=lf.val):
                return False
            que.append(lf.left)
            que.append(rg.right)
            que.append(lf.right)
            que.append(rg.left)
        return True

104. 二叉树的最大深度 - 力扣（LeetCode）

# 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
        lf=self.maxDepth(root.left)
        rg=self.maxDepth(root.right)
        return max(lf,rg)+1

559. N 叉树的最大深度 - 力扣（LeetCode）

"""
# Definition for a Node.
class Node:
    def __init__(self, val: Optional[int] = None, children: Optional[List['Node']] = None):
        self.val = val
        self.children = children
"""


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

111. 二叉树的最小深度 - 力扣（LeetCode）

# 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: Optional[TreeNode]) -> int:
        dep=0
        if not root:
            return dep
        lf=self.minDepth(root.left)
        rg=self.minDepth(root.right)
        if lf and not rg:
            return lf+1
        if not lf and rg:
            return rg+1
        return min(lf,rg)+1

100. 相同的树 - 力扣（LeetCode）

# 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 isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
        if not p and not q:
            return True
        elif not p and q:
            return False
        elif not q and p:
            return False
        else:
            if q.val !=p.val:
                return False
            else:
                lf=self.isSameTree(p.left,q.left)
                rg=self.isSameTree(p.right,q.right)
                return lf and rg

572. 另一棵树的子树 - 力扣（LeetCode）

# 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 isSame(self,p,q):
        if not p and not q:
            return True
        elif not p and q:
            return False
        elif p and not q:
            return False
        else:
            if p.val!=q.val:
                return False
            lf=self.isSame(p.left,q.left)
            rg=self.isSame(p.right,q.right)
            return lf and rg

    def isSubtree(self, root: Optional[TreeNode], subRoot: Optional[TreeNode]) -> bool:
        if not root:
            return False
        if self.isSame(root,subRoot):
            return True
        lf=self.isSubtree(root.left,subRoot)
        rg=self.isSubtree(root.right,subRoot)
        return lf or rg