代码随想录算法训练营第十四天| 226.翻转二叉树、101.对称二叉树、104.二叉树的最大深度、111.二叉树的最小深度

题目链接：226. 翻转二叉树 - 力扣（LeetCode）

思路：通过先序遍历根左右，每次遍历到root 都转换root.left 和 root.right，然后再继续遍历下一个root

 递归思路：

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:

        def invertTree(root):
            if root == None:
                return

            root.left, root.right = root.right, root.left
            invertTree(root.left)
            invertTree(root.right)

            return root

        invertTree(root)
        return root

统一迭代：

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        
        if root == None:
            return root

        help_stack = []

        help_stack.append(root)

        while len(help_stack) > 0:

            current = help_stack[-1]

            if current != None:
                help_stack.append(None)
                if current.left != None:
                    help_stack.append(current.left)
                if current.right != None:
                    help_stack.append(current.right)

            else:
                help_stack.pop()
                current = help_stack.pop()
                current.left, current.right = current.right, current.left

        return root

题目链接：101. 对称二叉树 - 力扣（LeetCode）

思路：以中心为轴两边镜面对称，判断是否镜面对称，本质就是树的遍历

递归思路：

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:

        def judgeSymmetric(left, right) -> bool:

            if left == None and right ==None:
                return True
            if left == None and right != None:
                return False
            if left != None and right == None:
                return False
            if left.val != right.val:
                return False                
            
            leftJudge = judgeSymmetric(left.left, right.right)
            rightJudge = judgeSymmetric(left.right, right.left)

            return leftJudge and rightJudge

        return judgeSymmetric(root.left, root.right)

统一迭代：

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:


        help_deque = deque()

        help_deque.append(root.left)
        help_deque.append(root.right)

        while len(help_deque) > 0:
            left = help_deque.popleft()
            right = help_deque.popleft()

            if left == None and right == None:
                continue
            
            if (left != None and right == None) or (left == None and right != None) or (left.val != right.val):
                return False

            help_deque.append(left.left)
            help_deque.append(right.right)
            help_deque.append(left.right)
            help_deque.append(right.left)

        return True

 

题目链接：104. 二叉树的最大深度 - 力扣（LeetCode）

思路：迭代法-->层序遍历 遍历到第几层就是多深；递归法--> 根节点的高度是指根节点到叶子节点的最长简单路径的条数或节点数，所以可以用后序遍历来求解

迭代法：

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if root == None:
            return 0

        help_deque = deque()
        help_deque.append(root)
        result = 0

        while len(help_deque) > 0:
            
            result += 1

            length = len(help_deque)

            for i in range(length):
                cur = help_deque.popleft()
                
                if cur.left != None:
                    help_deque.append(cur.left)

                if cur.right != None:
                    help_deque.append(cur.right)
        return result

递归法：

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if root == None:
            return 0

        def getResult(root) -> int:
            if root == None:
                return 0

            leftDepth = getResult(root.left)
            rightDepth = getResult(root.right)
            return 1 + max(leftDepth, rightDepth)

        return getResult(root)

题目链接：111. 二叉树的最小深度 - 力扣（LeetCode）

思路：同样是层序遍历 不同的是，遍历到叶子节点时就可以跳出循环了，因为叶子节点就是最小深度；递归法基本思路与最大深度相同，需要注意的是最小深度是根节点到叶子节点的距离，所以要考虑根节点如果左子树是空的情况

迭代法：

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if root == None:
            return 0

        help_deque = deque()
        help_deque.append(root)

        depth = 0

        while len(help_deque) > 0:
            
            depth += 1

            length = len(help_deque)

            for i in range(length):
                cur = help_deque.popleft()
                
                if cur.left != None:
                    help_deque.append(cur.left)

                if cur.right != None:
                    help_deque.append(cur.right)

                if cur.left == None and cur.right == None:
                    return depth

        return depth

递归法：

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if root == None:
            return 0

        def getResult(root) -> int:
            if root.left == None and root.right == None:
                return 0
            leftDepth = sys.maxsize
            rightDepth = sys.maxsize
            if root.left != None:
                leftDepth = getResult(root.left)
            if root.right != None:
                rightDepth = getResult(root.right)
            return 1 + min(leftDepth, rightDepth)

        return getResult(root) + 1