用递归反转 python 中的二叉树

Question

我查看了 inte.net 中反转二叉树的代码。 但我不知道它在做什么。 它写在Python。我自己是python程序员，但看不懂。

片段如下：

def invertTree(root):
    if root:
        root.left, root.right = invertTree(root.right), invertTree(root.left)
        return root

我不明白这个root.left和root.right 。 Root 是图中的主要节点，它将是一个 integer 或单个字符。 但是 Python 中的 root.left 代表什么？ 老实说，我不明白。

更新：

我的理解是节点访问如下：

class Node:
   def __init__(self, data):
      self.left = None
      self.right = None
      self.data = data
   def PrintTree(self):
      print(self.data)

root = Node(10)
root.PrintTree()

Answer 1

先用图来理解问题..！

问：- 给定二叉树，你必须将二叉树转换为倒置二叉树。 图表

Class TreeNode： {二叉树的初始化}

这里的关键见解是要认识到，为了反转二叉树，我们只需要递归地交换孩子。 为了避免使用 tmp 变量，我们可以通过利用 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 invertTree(self, root):
>         if root:
>             root.left, root.right = self.invertTree(root.right), self.invertTree(root.left)
>         return root

请注意，如果其中一个孩子是 null，则不会触发 root 的条件，并且仍然会执行上层的交换（例如节点有右孩子但没有左孩子，分配将是 root.left, root.右 = root.right，空）。

root.left 在做什么？ 遍历二叉树的左子树

root.right 在做什么？ 遍历二叉树的右子树。

注意您可以通过 root.val 访问 root 的值，如您所见的 class TreeNode。 我已将值存储在 val *

还要了解更多关于你应该做的二叉树基本问题。

(1)前序遍历

(2)中序遍历

(3)后序遍历

更新部分。！

Q-: 如何从另一个 class. 访问 root？

A-：只需在主 function.. 中调用它即可！

总机 Function

> if __name__="__main__":
>     s=input()
>     root=TreeNode(s)   
>     Solution().invertTree(root) 
>     inorderTraversal(root) # You can print in any other traversal also as the testcases requirements

更详细的看驱动代码（从第18行{下面链接}开始）： https://practice.geeksforgeeks.org/problems/mirror-tree/1

Answer 2

二叉树可用于存储按键排序的元素。（寻找平衡二叉树以获得更高级的主题。）如果元素按升序排序，对于根节点为 R 的任何子树 T，其中的任何元素R 的左分支应小于 R 右分支中的任何元素。

这是 Shivali Bhadaniya 的Invert a Binary Tree中示例代码的大量修改版本。

'''
         5                         5
       /   \                     /   \
      /     \                   /     \           
     3       7    =======>     7       3           
    / \     /                   \     / \
   1   4   6                     6   4   1 
'''
class Node:
    def __init__(self, data):
        self.left = self.right = None
        self.data = data
    def __repr__(self):
        return repr(self.data)

def invert(root):
    left, right = root.left, root.right
    print(['visiting', root, 'swapping', left, right])
    root.left, root.right = right, left
    if left: invert(left)
    if right: invert(right)

root = Node(5)
root.left = node3 = Node(3)
root.right = node7 = Node(7)
node3.left = Node(1)
node3.right = Node(4)
node7.left = Node(6)

invert(root)

这将 output 以下。

['visiting', 5, 'swapping', 3, 7]
['visiting', 3, 'swapping', 1, 4]
['visiting', 1, 'swapping', None, None]
['visiting', 4, 'swapping', None, None]
['visiting', 7, 'swapping', 6, None]
['visiting', 6, 'swapping', None, None]

在上面的例子中，调用invert()之前的树是按升序排序的。 调用后会降序排列。 这就是为什么该操作被称为“反转”的原因。

通过手动用铅笔和纸模拟上面的示例代码，您可以理解为什么交换左孩子和右孩子的简单递归会导致反转。 将日志与您的计算进行比较。