二叉树的的前序遍历和后序遍历（题型变种更新中）

变形一

BM32 合并二叉树

描述

已知两颗二叉树，将它们合并成一颗二叉树。合并规则是：都存在的结点，就将结点值加起来，否则空的位置就由另一个树的结点来代替。例如：
两颗二叉树是:
                                                                    Tree 1

                                                                        Tree 2

                                                                    合并后的树为

数据范围：树上节点数量满足0≤n≤500，树上节点的值一定在32位整型范围内。

进阶：空间复杂度 O(1) ，时间复杂度 O(n)

示例1

输入：

{1,3,2,5},{2,1,3,#,4,#,7}

返回值：

{3,4,5,5,4,#,7} 

示例2

输入：

{1},{}

返回值：

{1}

前序遍历

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param t1 TreeNode类 
     * @param t2 TreeNode类 
     * @return TreeNode类
     */
    public TreeNode mergeTrees (TreeNode t1, TreeNode t2) {
        // write code here
        if(t1==null)
            return t2;
        if(t2==null)
            return t1;
        t1.val+=t2.val;
        t1.left=mergeTrees(t1.left,t2.left);
        t1.right=mergeTrees(t1.right,t2.right);
        return t1; 
    }
}

 

变形二

BM33 二叉树的镜像

描述

操作给定的二叉树，将其变换为源二叉树的镜像。

数据范围：二叉树的节点数0≤n≤1000 ， 二叉树每个节点的值  0≤val≤1000

要求： 空间复杂度 O(n) 。本题也有原地操作，即空间复杂度 O(1) 的解法，时间复杂度 O(n)

比如：

源二叉树

镜像二叉树

示例1

输入：

{8,6,10,5,7,9,11}

返回值：

{8,10,6,11,9,7,5}    

示例2

输入：

{}

返回值：

{}

解题步骤：

1、特判：如果pRoot为空，返回空

2、交换左右子树
3、把pRoot的左子树放到Mirror中镜像一下
4、把pRoot的右子树放到Mirror中镜像一下
5、返回根节点root

前序和后序遍历

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pRoot TreeNode类 
     * @return TreeNode类
     */
    public TreeNode Mirror (TreeNode pRoot) {
        // write code here
        if(pRoot==null){
            return pRoot;
        }
//         //后序遍历
//         TreeNode left=Mirror(pRoot.left);  //递归左子树
//         TreeNode right=Mirror(pRoot.right);  //递归右子树
//         //左右子树交换    
//         pRoot.left=right;
//         pRoot.right=left;
        
        //前序遍历也可以
        TreeNode temp=pRoot.left;
        pRoot.left=pRoot.right;
        pRoot.right=temp;
        
        pRoot.left=Mirror(pRoot.left);
        pRoot.right=Mirror(pRoot.right);
        
        return pRoot;
    }
}

变形三 

BM36 判断是不是平衡二叉树

描述

输入一棵节点数为 n 二叉树，判断该二叉树是否是平衡二叉树。

在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树

平衡二叉树（Balanced Binary Tree），具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

样例解释：

样例二叉树如图，为一颗平衡二叉树

注：我们约定空树是平衡二叉树。

数据范围：0n≤100,树上节点的val值满足0≤n≤1000

要求：空间复杂度O(1)，时间复杂度O(n)

输入描述：

输入一棵二叉树的根节点

返回值描述：

输出一个布尔类型的值

示例1

输入：

{1,2,3,4,5,6,7}

返回值：

true

示例2

输入：

{}

返回值：

true

题解：（后序遍历）

求二叉树的高度的模板

public class Solution {
  
    boolean isb=true;  //标记是否是平衡二叉树
    public int dfs(TreeNode root){
        if(root==null){
            return 0;
        }
        //自底向上，先求左右子树高度
        int l=dfs(root.left);
        
        int r=dfs(root.right);
        
        if(Math.abs(l-r)>1){  //(左子树深度-右子树深度) > 1，不是平衡树
            isb=false;
        }
        
        return Math.max(l,r)+1;  //求深度
    }
    public boolean IsBalanced_Solution(TreeNode root) {
        if(root==null){
            return true;
        }
         dfs(root);
         return isb;    
    }
}

上面的代码总是遍历完全部的节点，如果一判断到左右子树的深度之差大于1，即这个二叉树就不可能再是平衡树了。所以，我们还可以对上面代码进行优化。

进行剪枝：当判断到左右子树的深度之差大于1的时候，则返回-1。每次递归结束判断返回值是否-1，若为-1，则立即返回。

所以优化后的代码为：

public class Solution {  
    boolean isb=true;
    public int dfs(TreeNode root){
        if(root==null){
            return 0;
        }
        //自底向上，先求左右子树高度
        int l=dfs(root.left);
        if(l==-1){  //如果左子树已经不是平衡二叉树，则返回-1，不需要再去访问右子树了
            return -1;
        }
        int r=dfs(root.right);
        if(r==-1){  //如果右子树已经不是平衡二叉树，则返回-1，不需要再去访问递归了
            return -1;
        }
        if(Math.abs(l-r)>1){  //(左子树深度-右子树深度) > 1，不是平衡树
            isb=false;
            return -1;  //提前结束，避免遍历所有的节点
        }
        
        return Math.max(l,r)+1;  //求深度
    }
    public boolean IsBalanced_Solution(TreeNode root) {
        if(root==null){
            return true;
        }

        int len=dfs(root);
        if(len==-1){
            return false;
        }
        else{
            return true;
        }
            
    }
}

变形四

BM37 二叉搜索树的最近公共祖先

描述

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

1.对于该题的最近的公共祖先定义:对于有根树T的两个节点p、q，最近公共祖先LCA(T,p,q)表示一个节点x，满足x是p和q的祖先且x的深度尽可能大。在这里，一个节点也可以是它自己的祖先.

2.二叉搜索树是若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值

3.所有节点的值都是唯一的。

4.p、q 为不同节点且均存在于给定的二叉搜索树中。

数据范围:

3<=节点总数<=10000

0<=节点值<=10000

如果给定以下搜索二叉树: {7,1,12,0,4,11,14,#,#,3,5}，如下图:

 代码：

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @param p int整型 
     * @param q int整型 
     * @return int整型
     */

    public int lowestCommonAncestor (TreeNode root, int p, int q) {
        // write code here
       //避免了判断p,q值那个大
        if((p-root.val)*(q-root.val)<=0){  //两个节点值在root左右两边
            return root.val;
        }
        else if(p>root.val&&q>root.val){
            return lowestCommonAncestor(root.right,p,q);
        }else{
            return lowestCommonAncestor(root.left,p,q);
        }
     }
            
}

变形五（一般二叉树找最近公共节点）（前序遍历）

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @param p int整型 
     * @param q int整型 
     * @return int整型
     */

    public int lowestCommonAncestor (TreeNode root, int p, int q) { 
        //一般二叉树
        if(root==null){  //没有找到p或者q
            return -1;  //返回-1
        }
        //前序遍历：根左右
        if(root.val==p||root.val==q){  //如果遍历到其中一个节点，则该节点就是两个节点最近祖先
           return root.val;    //两个节点的祖先
        }
        int l=lowestCommonAncestor(root.left,p,q);
        int r=lowestCommonAncestor(root.right,p,q);
        if(l==-1){  //如果左子树中没有两个节点p,q,则说明两个节点都在右子树上
            return r;    //返回右子树第一个遇到的节点，就是最近公共祖先
        }
        if(r==-1){ //如果右子树中没有两个节点p,q,则说明两个节点都在左子树上
           return l;   // 返回右子树第一个遇到的节点，就是最近公共祖先
        }
        return root.val;    //如果左右子树各有一个节点值，则他们的最近公共节点是root.val
     }
}