跟随carl代码随想录刷题
语言：python

---

226. 简单翻转二叉树

题目：给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

题目分析

思路：交换每个节点的左右节点即可root.left, root.right = root.right, root.left
方法选择：

• 前序遍历💚✔
• 中序遍历【❌不能用，因为会把所有节点交换两次】
• 后序遍历💚✔
• 层序遍历💚✔

完整代码如下

方法1.1：前序遍历——递归法

# 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]:
        if root == None:
            return None
        
        # 交换节点
        root.left, root.right = root.right, root.left  # 中
        self.invertTree(root.left)  # 左
        self.invertTree(root.right)  # 右

        return root
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

方法1.2：后序遍历——递归法

# 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]:
        if root == None:
            return None
        
        self.invertTree(root.left)  # 左
        self.invertTree(root.right)  # 右

        # 交换节点
        root.left, root.right = root.right, root.left  # 中

        return root
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

方法2.1：前序遍历——迭代法

# 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]:
        
        if not root:
            return None

        st = []
        st.append(root)
        while st:
            node = st.pop()
            node.left, node.right = node.right, node.left  # 中
            if node.right:
                st.append(node.right)  # 左
            if node.left:
                st.append(node.left)  # 右
        return root 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

方法2.2：后序遍历——迭代法

# 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]:
        
        if not root:
            return None

        st = []
        st.append(root)
        while st:
            node = st.pop()
            
            if node.right:
                st.append(node.right)  # 左
            if node.left:
                st.append(node.left)  # 右
            node.left, node.right = node.right, node.left  # 中
        return root 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

方法3：层序遍历

# 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]:
        
        if not root:
            return None
        
        from collections import deque
        que = deque([root])

        while que:
            size = len(que)
            cur = que.popleft()
            cur.left, cur.right = cur.right, cur.left
            if cur.left:
                que.append(cur.left)
            if cur.right:
                que.append(cur.right)
        return root

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25