给你一棵二叉树的根节点 root ,翻转这棵二叉树,并返回其根节点。python

class Solution:
def invertTree(self, root: TreeNode) -> TreeNode:
if not root:
return None

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

root.left, root.right = right, left

return root

相关问题

python翻转二叉树

Python翻转二叉树可以使用递归实现。具体实现方法如下：
1. 当根节点为空时，返回None。
2. 递归调用自身，先翻转左子树。
3. 递归调用自身，翻转右子树。
4. 将左右子树交换，并返回根节点。

下面是Python代码实现：

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: TreeNode) -> TreeNode:
        if root == None:
            return None
        self.invertTree(root.left)
        self.invertTree(root.right)
        temp = root.left
        root.left = root.right
        root.right = temp
        return root

设计一个python算法：给定一棵二叉树，要求输出其左右翻转后二叉树的中序遍历。 思路：镜像翻转：只需要遍历二叉树，每次访问一个结点时，交换其左右孩子，然后递归的翻转左右孩子。

好的，这是一个很有意思的问题，以下是我的 Python 实现：

# 定义二叉树节点
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

# 镜像翻转二叉树
def mirror(root):
    if not root:
        return
    root.left, root.right = root.right, root.left
    mirror(root.left)
    mirror(root.right)

# 中序遍历二叉树
def inorder(root):
    if not root:
        return []
    res = []
    res += inorder(root.left)
    res.append(root.val)
    res += inorder(root.right)
    return res

# 获取左右翻转后的中序遍历结果
def get_flip_inorder(root):
    # 镜像翻转二叉树
    mirror(root)
    # 获取左右翻转后的中序遍历结果
    res = inorder(root)
    # 再次镜像翻转二叉树，将其回复原状
    mirror(root)
    return res

# 测试代码
if __name__ == '__main__':
    root = TreeNode(4)
    root.left = TreeNode(2)
    root.right = TreeNode(7)
    root.left.left = TreeNode(1)
    root.left.right = TreeNode(3)
    root.right.left = TreeNode(6)
    root.right.right = TreeNode(9)

    print(get_flip_inorder(root))

这个算法的时间复杂度是 $O(n)$，其中 $n$ 是二叉树中的节点数。