LeetCode 226. 翻转二叉树https://leetcode.cn/problems/invert-binar

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

输入： root = [4,2,7,1,3,6,9]
输出： [4,7,2,9,6,3,1]

示例 2：

输入： root = [2,1,3]
输出： [2,3,1]

示例 3：

输入： root = []
输出： []

提示：

树中节点数目范围在 [0, 100] 内
-100 <= Node.val <= 100

如果要从整个树来看，翻转还真的挺复杂，整个树以中间分割线进行翻转，如图：

226.翻转二叉树1

可以发现想要翻转它，其实就把每一个节点的左右孩子交换一下就可以了。

遍历的过程中去翻转每一个节点的左右孩子就可以达到整体翻转的效果。

注意只要把每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果

这道题目使用前序遍历和后序遍历都可以，唯独中序遍历不方便，因为中序遍历会把某些节点的左右孩子翻转了两次！建议拿纸画一画，就理解了

那么层序遍历可以不可以呢？依然可以的！只要把每一个节点的左右孩子翻转一下的遍历方式都是可以的！

递归法

我们下文以前序遍历为例，通过动画来看一下翻转的过程:

翻转二叉树

我们来看一下递归三部曲：

确定递归函数的参数和返回值

参数就是要传入节点的指针，不需要其他参数了，通常此时定下来主要参数，如果在写递归的逻辑中发现还需要其他参数的时候，随时补充。

返回值的话其实也不需要，但是题目中给出的要返回root节点的指针，可以直接使用题目定义好的函数，所以就函数的返回类型为TreeNode*。

TreeNode* invertTree(TreeNode* root)

确定终止条件

当前节点为空的时候，就返回

if (root == NULL) return root;

确定单层递归的逻辑

因为是前序遍历，所以先进行交换左右孩子节点，然后反转左子树，反转右子树。

swap(root->left, root->right);
invertTree(root->left);
invertTree(root->right);

基于这递归三步法，代码基本写完，C++代码如下：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        swap(root->left, root->right);  // 中
        invertTree(root->left);         // 左
        invertTree(root->right);        // 右
        return root;
    }
};

kotlin 代码如下：

class Solution {
    fun invertTree(root: TreeNode?): TreeNode? {
        if (root == null) return root
        val temp = root.left
        root.left = root.right
        root.right = temp
        invertTree(root.left)
        invertTree(root.right)
        return root
    }
}

深度优先遍历

基于前序遍历，kotlin 代码：

class Solution {
    fun invertTree(root: TreeNode?): TreeNode? {
        val stack = Stack<TreeNode>()
        stack.push(root)
        while (stack.isNotEmpty()) {
            val top = stack.pop()
            if (top != null) {
                val temp = top.left
                top.left = top.right
                top.right = temp
                if (top.right != null) {
                    stack.push(top.right)
                }
                if (top.left != null) {
                    stack.push(top.left)
                }
            }
        }
        return root
    }
}

广度优先遍历

也就是层序遍历，层数遍历也是可以翻转这棵树的，因为层序遍历也可以把每个节点的左右孩子都翻转一遍，代码如下：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                swap(node->left, node->right); // 节点处理
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};

kotlin 代码：

class Solution {
    fun invertTree(root: TreeNode?): TreeNode? {
        if (root == null) return root
        val queue = Stack<TreeNode>()
        queue.push(root)
        while (queue.isNotEmpty()) {
            val size = queue.size
            for (i in 0..<size) {
                val cur = queue.pop()
                val temp = cur.left
                cur.left = cur.right
                cur.right = temp
                if (cur.left != null) {
                    queue.push(cur.left)
                }
                if (cur.right != null) {
                    queue.push(cur.right)
                }
            }
        }
        return root
    }
}