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中，可以通过递归的方式来实现这个操作。下面是一个简单的示例代码，展示了如何在Python中翻转一个二叉树：

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def invertTree(root):
    if root:
        # 交换左右子节点
        root.left, root.right = root.right, root.left
        # 递归翻转左子树和右子树
        invertTree(root.left)
        invertTree(root.right)
    return root

# 使用示例
# 创建一个简单的二叉树
#     1
#    / \
#   2   3
#  / \ / \
# 4  5 6  7
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right.left = TreeNode(6)
root.right.right = TreeNode(7)

# 翻转这棵树
invertTree(root)

# 翻转后的树结构
#     1
#    / \
#   3   2
#  / \ / \
# 7  6 5  4

python实现二叉树的遍历

二叉树是一种数据结构，其中每个节点最多有两个子节点。二叉树的遍历是指按照一定的顺序访问二叉树中的所有节点。常见的遍历方式有前序遍历、中序遍历和后序遍历。

以下是Python实现二叉树遍历的代码示例：

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        """
        前序遍历：根节点 -> 左子树 -> 右子树
        """
        if not root:
            return []
        res = []
        stack = [root]
        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
        return res

    def inorderTraversal(self, root: TreeNode) -> List[int]:
        """
        中序遍历：左子树 -> 根节点 -> 右子树
        """
        if not root:
            return []
        res = []
        stack = []
        node = root
        while stack or node:
            while node:
                stack.append(node)
                node = node.left
            node = stack.pop()
            res.append(node.val)
            node = node.right
        return res

    def postorderTraversal(self, root: TreeNode) -> List[int]:
        """
        后序遍历：左子树 -> 右子树 -> 根节点
        """
        if not root:
            return []
        res = []
        stack = [root]
        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
        return res[::-1]

上述代码中，我们定义了一个`TreeNode`类来表示二叉树节点，包括节点的值`val`、左子节点`left`和右子节点`right`。然后我们定义了一个`Solution`类，其中包含了三个函数，分别实现了前序遍历、中序遍历和后序遍历。

对于前序遍历，我们使用一个栈来存储节点，初始时将根节点加入栈中，然后循环执行以下操作：弹出栈顶节点并将其值加入结果列表，如果该节点的右子节点不为空，则将其右子节点加入栈中，如果该节点的左子节点不为空，则将其左子节点加入栈中。最后返回结果列表。

对于中序遍历，我们同样使用一个栈来存储节点，初始时将根节点加入栈中，然后循环执行以下操作：将当前节点的左子节点全部加入栈中，然后弹出栈顶节点并将其值加入结果列表，最后将当前节点置为其右子节点。如果当前节点为空且栈不为空，则弹出栈顶节点并继续执行上述操作。最后返回结果列表。

对于后序遍历，我们可以在前序遍历的基础上做一些修改，具体来说，先按照前序遍历的方式访问节点，并将节点加入结果列表中，然后将结果列表翻转即可得到后序遍历的结果。

以上就是Python实现二叉树遍历的示例代码。