leetcode刷题笔记1 二叉树part02

leetcode 226 翻转二叉树

递归法

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

迭代法

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return None
        stack = [root]
        while stack:
            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 None
        queue = collections.deque([root])
        while queue:
            node = queue.popleft()
            node.left, node.right= node.right, node.left
            if node.left: queue.append(node.left)
            if node.right: queue.append(node.right)
        return root

leetcode101. 对称二叉树

 递归法

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        return self.compare(root.left, root.right)
    def compare(self, left, right):
        if left == None and right == None: return True
        elif left != None and right == None: return False
        elif left == None and right != None: return False
        elif left.val != right.val: return False
        outside = self.compare(left.left, right.right)
        inside = self.compare(left.right, right.left)
        return outside and inside

迭代法

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        queue = collections.deque()
        queue.append(root.left)
        queue.append(root.right)
        while queue:
            leftNode = queue.popleft()
            rightNode = queue.popleft()
            if not leftNode and not rightNode:
                continue
            if not leftNode or not rightNode or leftNode.val != rightNode.val:
                return False
            queue.append(leftNode.left)
            queue.append(rightNode.right)
            queue.append(leftNode.right)
            queue.append(rightNode.left)
        return True

leetcode104 二叉树的最大深度

递归法：

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

    def get_depth(self,node):
        if not node:
            return 0
        leftheight = self.get_depth(node.left)
        rightheight = self.get_depth(node.right)
        height = 1 + max(leftheight,rightheight)
        return height

层序遍历法：
 

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

leetcode111 二叉树的最小深度

递归法：
        递归判断时需要注意

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        return self.getDepth(root)
    def getDepth(self, node):
        if node is None:
            return 0
        leftdepth = self.getDepth(node.left)
        rightdepth = self.getDepth(node.right)
        if node.left is None and node.right is not None:
            return 1 + rightdepth
        if node.left is not None and node.right is None:
            return 1 + leftdepth
        result = 1 + min(leftdepth, rightdepth)
        return result

 层序遍历法：
        终止条件是左孩子和右孩子同时不存在

class Solution:
    def minDepth(self, root: Optional[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()
                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