【详细整理】二叉树的遍历+力扣617合并二叉树 226翻转二叉树

一、二叉树遍历构架

刚开始刷二叉树的题，边刷边学，第一次接触二叉树，递归真是看得人：我是谁 我在哪，整理一下今天学的内容，复习同时以便以后自己查阅。如果有错误或者疏漏，欢迎大家补充交流。

二叉树遍历构架：

 void traverse(TreeNode root){
        if(root == null){
            return null;
        }
        // 前序遍历，根的处理在前面
        traverse(root.left);#左子树
        // 中序遍历，根的处理在中间
        traverse(root.right);#右子树
        // 后序遍历，根的处理在最后
        }  

    }

先序：根左右，中序：左根右；后续：左右根
自己总结了一个遍历的剥洋葱准则（递归中递的过程）：
剥到左（右）节点，只要它有子节点，他的身份里面变为父节点（根），此时他的父亲身份优先级大于左（右）节点身份，必须先考虑它的孩子，直到它没有孩子。

二、遍历举例

一个非常简单的例子：

前序遍历：根左右，遍历的输出结果就是：4213769
中序遍历：左根右，遍历结果：1234679
（左：一直剥到：1，根：2，右：3；一个子树归完，上一个树，左2已经走过，跟：4，右7因为是父亲，身份立马转换为根，先考虑孩子，向下剥到左：6，根：7，右：9）
后序遍历：左右根，遍历结果：1326974

树其实内在的遍历递归顺序如上图，所谓的前序、中序、后序就是处理数据的前后顺序不一样。
前序先处理根节点后左右，中序先处理左节点，后根右；后序先处理左右节点，最后处理根节点。

三、遍历架构实操——力扣题

1、617 合并二叉树

（1）题目：

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

（2）分析解答

要求从根节点开始，所以使用先序遍历框架。需要合并成一个新的二叉树，定一个一个新的树，它的节点值为两个树相应位置节点值的和。都null时返回null。

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
    //    边界条件 （不是边界条件，是元素值返回，一个节点为空则返回另一个的值，俩都空就null ）
        if (root1==null){
            return root2;
        }
        if (root2==null){
            return root1;
        }
    // 大框架是一个先序遍历：根左右
    // 定义一个二叉树，他的数据域（val是不是直白的就是value）等于两个数的数据之和
    // 看了评论发现想错了，这个位置就是根节点值位置，就是定义一个新节点先合并根节点值
    //应该是定义一棵新的树，它的节点值等于两棵树对应位置的和，先处理根节点
        TreeNode merge = new TreeNode(root1.val+root2.val);
       
        // 递归合并左右子树
         // 将root1 的左树和root2的左树之和作为merge的左树
         //将root1 的右树和root2的右树之和作为merge的右树
        merge.left = mergeTrees(root1.left,root2.left);
        merge.right = mergeTrees(root1.right,root2.right);
        return merge;
    }

这是接触的树的第一题，看完只觉得，哇，树好神奇我的妈。

2、226翻转二叉树

（1）题目

（2）分析解答

自己还是没写出来，看的官方解答和评论。
“做这三件事情(1.将左子树所有的节点reverse; 2.将右子树所有的节点reverse; 3.把左子树和右子树的根节点reverse)的顺序决定了是前序,中序,还是后序.”（——来自题目评论中xswl的评论，因为没法放链接，侵删）

//前序遍历
public TreeNode invertTree(TreeNode root) {
    if(root == null)    return root;
    TreeNode temp = root.left;
    root.left = root.right;//根
    root.right = temp;//根
    invertTree(root.left);//左
    invertTree(root.right);//右
    return root;
}
//中序遍历
public TreeNode invertTree(TreeNode root) {
    if(root == null)    return root;
    invertTree(root.left);//左
    TreeNode temp = root.left;
    root.left = root.right;//根
    root.right = temp;//根
    invertTree(root.left);//右
    return root;
}
//后序遍历
public TreeNode invertTree(TreeNode root) {
    if(root == null)    return root;
    invertTree(root.left);//左
    invertTree(root.right);//右
    TreeNode temp = root.left;
    root.left = root.right;//根
    root.right = temp;//根
    return root;
}
//层序遍历
public TreeNode invertTree(TreeNode root) {
    if(root == null)    return root;
    Queue<TreeNode> queue = new LinkedList<>();
    queue.add(root);
    while(!queue.isEmpty()){
        TreeNode cur = queue.remove();
        TreeNode temp = cur.left;
        cur.left = cur.right;
        cur.right = temp;
        if(cur.left != null)  queue.add(cur.left);
        if(cur.right != null) queue.add(cur.right);
    }
    return root;
}
}

上面这个代码我觉得比较好理解，评论热评第一的代码如下（这个真的把我有点绕晕）：

class Solution {
        // 先序遍历--从顶向下交换
        public TreeNode invertTree(TreeNode root) {
            if (root == null) return null;
            // 保存右子树
            TreeNode rightTree = root.right;
            // 交换左右子树的位置
            root.right = invertTree(root.left);
            root.left = invertTree(rightTree);
            return root;
        }
    }
利用中序遍历
class Solution {
    public TreeNode invertTree(TreeNode root) {
            if (root == null) return null;
            invertTree(root.left); // 递归找到左节点
            TreeNode rightNode= root.right; // 保存右节点
            root.right = root.left;
            root.left = rightNode;
            // 递归找到右节点 继续交换 : 因为此时左右节点已经交换了,所以此时的右节点为root.left
            invertTree(root.left); 
    }
}
利用后序遍历
 class Solution {
        public TreeNode invertTree(TreeNode root) {
            // 后序遍历-- 从下向上交换
            if (root == null) return null;
            TreeNode leftNode = invertTree(root.left);
            TreeNode rightNode = invertTree(root.right);
            root.right = leftNode;
            root.left = rightNode;
            return root;
        }
    }
利用层次遍历
   class Solution {
        public TreeNode invertTree(TreeNode root) {
            // 层次遍历--直接左右交换即可
            if (root == null) return null;
            Queue<TreeNode> queue = new LinkedList<>();
            queue.offer(root);
            while (!queue.isEmpty()){
                TreeNode node = queue.poll();
                TreeNode rightTree = node.right;
                node.right = node.left;
                node.left = rightTree;
                if (node.left != null){
                    queue.offer(node.left);
                }
                if (node.right != null){
                    queue.offer(node.right);
                }
            }
            return root;
        }
    }

自己照着写，然后出现了一些非常有趣的：

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null){
            return null;
        }
        // 先序遍历——自顶向下交换
        TreeNode rightTree = root.right;
        root.right=invertTree(root.left);
        root.left=rightTree;
        //这样的话右子树没有往下递归，第一步把右子树值赋给了rightTree
        //上一步调换左右子树，这一步的左子树就相当于右子树，赋给了同样的值，同一级别的右子树没有往下递归。        
        return root;
}