力扣刷题-二叉树-翻转二叉树

226.翻转二叉树

翻转一棵二叉树。

思路

参考：
https://www.programmercarl.com/0226.%E7%BF%BB%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91.html#%E6%80%9D%E8%B7%AF
如果要从整个树来看，翻转还真的挺复杂，整个树以中间分割线进行翻转，如图：
可以发现想要翻转它，其实就把每一个节点的左右孩子交换一下就可以了。
注意：交换孩子其实交换的是指针
关键在于遍历顺序，前中后序应该选哪一种遍历顺序？（一些同学这道题都过了，但是不知道自己用的是什么顺序）
遍历的过程中去翻转每一个节点的左右孩子就可以达到整体翻转的效果。
注意只要把每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果
这道题目使用前序遍历和后序遍历都可以，唯独中序遍历不方便，因为中序遍历会把某些节点的左右孩子翻转了两次！建议拿纸画一画，就理解了
那么层序遍历可以不可以呢？依然可以的！只要把每一个节点的左右孩子翻转一下的遍历方式都是可以的！

代码

递归法（前序遍历）

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

class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:
            return root
        root.left, root.right = root.right, root.left # 交换 因为是中左右 第一次先遇到中 所以先交换
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root

写递归的三点：
递归函数的参数：本题只要是node（当前遍历的“中”节点，力扣上为root）
终止条件：遇到空节点
单层逻辑/处理逻辑：交换左右孩子

时间复杂度：O(N) 其中 N 为二叉树节点的数目。我们会遍历二叉树中的每一个节点，对每个节点而言，我们在常数时间内交换其两棵子树。
空间复杂度：O(N) 使用的空间由递归栈的深度决定，它等于当前节点在二叉树中的高度。在平均情况下，二叉树的高度与节点个数为对数关系，即 O(log⁡N)。而在最坏情况下，树形成链状，空间复杂度为 O(N)。

递归（后序遍历）

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

class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:
            return root
        # root.left, root.right = root.right, root.left # 交换 因为是中左右 第一次先遇到中 所以先交换
        self.invertTree(root.left)
        self.invertTree(root.right)
        root.left, root.right = root.right, root.left # 交换 后序遍历 因为是左右中 最后先遇到中 所以最后交换
        return root

迭代（前序遍历）

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

class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:
            return root
        stack = [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 Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:
            return root
        stack = [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)
            node.left, node.right = node.right, node.left
        return root

层序遍历

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

class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:
            return root

        queue = deque([root])
        while queue:
            for _ in range(len(queue)):
                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