leetcode(二叉树) 翻转二叉树

                                                 翻转二叉树

 

1、题目：  

    翻转一棵二叉树。

    示例：

    输入：

        

    输出：

        

2、解题步骤：

    (1) 方案一：递归

        a、题解：

            翻转一棵空树结果还是一棵空树。对于一棵根为 r，左子树为 \mbox{left}，右子树为\mbox{right}的树来说，它的翻转树是一棵根为 r，左子树为\mbox{left}的翻转树，右子树为\mbox{right}翻转树的树。

        b、代码：           

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


class BinTree():
    def __init__(self, root=None):
        self.root = root

    def preTraverse(self, root):
        """先（根）序遍历"""
        if root is None:
            return
        print(root.value)   # 递归处理根
        self.preTraverse(root.left)     # 递归处理左子树
        self.preTraverse(root.right)    # 递归处理右子树


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

        # root.left, root.right = root.right, root.left
        # self.invertTree(root.right)
        # self.invertTree(root.left)
        root.left, root.right = self.invertTree(root.right), self.invertTree(root.left)
        return root


if __name__ == "__main__":
    root = TreeNode("4",
                    TreeNode("2", TreeNode("1"), TreeNode("3")),
                    TreeNode("7", TreeNode("6"), TreeNode("9"))
                    )
    binTree = BinTree()
    print("翻转前：")
    binTree.preTraverse(root)
    solution = Solution()
    result = solution.invertTree(root)
    print("翻转后：")
    binTree.preTraverse(root)

        c、运行结果：      

翻转前：
4
2
1
3
7
6
9
翻转后：
4
7
9
6
2
3
1

    (2) 方案二：迭代

        a、题解：

            我们需要交换树种所有节点的左孩子和右孩子。因此可以创建一个队列来存储所有左孩子和右孩子还没有被交换过的节点。开始的时候，只有根节点在这个队列里面。只要这个队列不为空，就一直从队列中出队节点，然后互换这个节点的左右两个孩子节点，接着再把孩子节点入队到队列，对于其中的空节点不需要加入队列。最终队列一定会空，这时候所有节点的孩子节点都被互换过了，直接返回最初的根节点就可以了。

        b、代码：            

from collections import deque


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


class BinTree():
    def __init__(self, root=None):
        self.root = root

    def preTraverse(self, root):
        """先（根）序遍历"""
        if root is None:
            return
        print(root.value)   # 递归处理根
        self.preTraverse(root.left)     # 递归处理左子树
        self.preTraverse(root.right)    # 递归处理右子树


class Solution:
    def __init__(self):
        self.queue = deque()

    def empty(self):
        """
        判断队列是否为空队列
        """
        return len(self.queue) == 0

    def invertTree(self, root: TreeNode) -> TreeNode:
        if root is None:
            return None

        self.queue.append(root)

        while not self.empty():
            current = self.queue.popleft()    # 从队列左端移除元素，返回移除的元素
            current.left, current.right = current.right, current.left
            if current.left:
                self.queue.append(current.left)
            if current.right:
                self.queue.append(current.right)
        return root


if __name__ == "__main__":
    root = TreeNode("4",
                    TreeNode("2", TreeNode("1"), TreeNode("3")),
                    TreeNode("7", TreeNode("6"), TreeNode("9"))
                    )
    binTree = BinTree()
    print("翻转前：")
    binTree.preTraverse(root)
    solution = Solution()
    result = solution.invertTree(root)
    print("翻转后：")
    binTree.preTraverse(root)

        c、运行结果：          

翻转前：
4
2
1
3
7
6
9
翻转后：
4
7
9
6
2
3
1