0226-翻转二叉树

翻转一棵二叉树。

示例：

输入：

输出：

备注:
这个问题是受到 Max Howell 的 原问题 启发的 ：

谷歌：我们90％的工程师使用您编写的软件(Homebrew)，但是您却无法在面试时在白板上写出翻转二叉树这道题，这太糟糕了。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/invert-binary-tree

参考：

• https://leetcode-cn.com/problems/invert-binary-tree/solution/dai-ma-sui-xiang-lu-226-fan-zhuan-er-cha-8tvd/

python

# 0226.翻转二叉树
class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        """
        递归法-前序遍历
        :param root:
        :return:
        """
        if not root:
            return None
        # 中-N
        root.left, root.right = root.right, root.left
        # 左—L
        self.invertTree(root.left)
        # 右-R
        self.invertTree(root.right)
        return root

class Solution2:
    def invertTree(self, root: TreeNode) -> TreeNode:
        """
        迭代法-深度优先遍历-前序遍历
        :param root:
        :return:
        """
        if not root:
            return root

        stack = []
        stack.append(root)
        while stack:
            node = stack.pop()
            node.left, node.right = node.right, node.left
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
        return root

class Solution3:
    def invertTree(self, root: TreeNode) -> TreeNode:
        """
        迭代法-广度优先遍历-层序遍历
        :param root:
        :return:
        """
        from collections import deque
        queue = deque()
        if root:
            queue.append(root)
        while queue:
            size = len(queue)
            for i in range(size):
                node = queue.popleft()
                node.left, node.right = node.right, node.left
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return root

golang

package binaryTree

import "container/list"

// 递归法-前序遍历
func invertTree1(root *TreeNode) *TreeNode {
	if root == nil {
		return root
	}
	root.Left, root.Right = root.Right, root.Left
	invertTree1(root.Left)
	invertTree1(root.Right)
	return root
}

// 迭代法-深度优先-前序遍历
func invertTree2(root *TreeNode) *TreeNode {
	if root == nil {
		return root
	}
	stack := list.New()
	stack.PushBack(root)
	for stack.Len() > 0 {
		e := stack.Back()
		stack.Remove(e)
		node := e.Value.(*TreeNode)
		node.Left, node.Right = node.Right, node.Left
		if node.Right != nil {
			stack.PushBack(node.Right)
		}
		if node.Left != nil {
			stack.PushBack(node.Left)
		}
	}
	return root
}

// 迭代法-广度优先-层序遍历
func invertTree3(root *TreeNode) *TreeNode {
	queue := list.New()
	if root != nil {
		queue.PushBack(root)
	}
	for queue.Len() > 0 {
		length := queue.Len()
		for i:=0;i<length;i++ {
			node := queue.Remove(queue.Front()).(*TreeNode)
			node.Left, node.Right = node.Right, node.Left
			if node.Left != nil {
				queue.PushBack(node.Left)
			}
			if node.Right != nil {
				queue.PushBack(node.Right)
			}
		}
	}
	return root
}