二叉树递归练习

（1）
题目：

请把纸条竖着放在桌面上，然后从纸条的下边向上⽅对折，压出折痕后再展开。此时有1条折痕，突起的⽅向指向纸条

的背面，这条折痕叫做“下”折痕 ；突起的面向指向纸条正⾯的折痕叫做“上”折痕。如果每次都从下边向上面对

折，对折N次。请从上到下计算出所有折痕的面向。

给定折的次数n,请返回从上到下的折痕的数组，若为下折痕则对应元素为"down",若为上折痕则为"up".

思路：找张纸试几次就会发现，这其实是一棵满二叉树，树的根是“下”，左孩子是“上”，右孩子是“下”。遍历

顺序是“右，中，左”

public class FoldPaper {
    public String[] foldPaper(int n) {
        // write code here
        List<String> list=new ArrayList();
        fold(1,n,true,list);
        String[] res=new String[list.size()];
        for(int i=0;i<list.size();i++){
            res[i]=list.get(i);
        }
        return res;
    }
    
    public void fold(int i,int n,boolean down,List<String> list){//i--当前层数    遍历顺序：右，中，左，（左上右下的树）
        if(i>n) return ;
        fold(i+1,n,true,list);
        list.add(down?"down":"up");//加入down
        fold(i+1,n,false,list);
    }
}

（2）

一棵二叉树原本是搜索二叉树，但是其中有两个节点调换了位置，使得这棵二叉树不再是搜索二叉树，请找到这两个

错误节点并返回他们的值。保证二叉树中结点的值各不相同。

给定一棵树的根结点，请返回两个调换了位置的值，其中小的值在前。

思路：

中序遍历搜索二叉树的结果是升序的，比如1 2 3 4 5 6

两个节点位置交换发生错误，有两种情况 1 5 3 4 2 6，有两次降序的分别为5 3和2 6，错误节点是第一次降序的

max，和第二次降序的min；第二种情况1 2 4 3 5 6 ，有一次降序的即4 3，第一个错误是max=4，第二个是min=3.

综合来看，就是找出中序遍历结果中，第一次降序的max，和最后一次降序的min。

public class FindErrorNode {
    public int[] findError(TreeNode root) {
        // write code here
        if(root==null) return null;
        Stack<TreeNode> s=new Stack();
        int[] result=new int[2];
        result[0]=result[1]=-1;
        TreeNode p=root;
        TreeNode top=null;
        boolean first=true;
        while(!s.isEmpty()||p!=null){
            if(p!=null){
                s.push(p);
                p=p.left;
            }else{
                p=s.pop();
                if(top!=null&&top.val>p.val){//p为当前节点，top上一次为弹出的栈顶
                    result[1]=(result[1]==-1?top.val:result[1]);//结果输出为最小值在前面
                    result[0]=p.val;
                }
               	top=p;
                p=p.right;
            }
        }
        return result;
    }
}

（3）

题目：

从二叉树的节点A出发，可以向上或者向下走，但沿途的节点只能经过一次，当到达节点B时，路径上的节点数叫作A到B的距离。对于给定的一棵二叉树，求整棵树上节点间的最大距离。给定一个二叉树的头结点root，请返回最大距离。保证点数大于等于2小于等于500.

思路：

理解题目的含义，对于一棵以root为根的二叉树，树上的最大距离可能来自3中情况：

情况1：完全来自root的左子树，如图所示，即最大路径不经过root结点，只在结点1的左子树2上面，此时的最大距离为8。

情况2：完全来自root结点的右子树，如图所示，最大路径不经过root结点，只在结点1的右侧左子树3上面，此时最大距离是9。

情况3：来自结点root的两侧，如图所示，经过root结点，此时的最大距离=root的左子树的高度（即结点3的最长路径）+root右子树的高度（即结点3的最长路径）+root结点本身。

分析可知，要计算结点root所在子树的最长距离，需要已知：左子树②的最长距离LMaxLength，左子树的高度LHeight；右子树③的最长距离RMaxLength，右子树的高度RHeight.然后max(LMax,RMax,(LHeight+RHeight+1))，其最大值就是这棵二叉树的最大距离，即对于每个子树，需要求出它的最大距离和最大高度。

显然这就是一个递推关系式，可以使用递归来实现，即设计一个递归函数，给定一个根结点root,求出最大距离max和最大高度height并返回这2个数值。其中maxLength= Math.max(LMax,RMax,(LHeight+RHeight+1))；而由于要返回这棵子树的高度，如何求子树的高度呢？二叉树的高度就是它的2个子树高度中的较大值再加上1，即height=Math.max(LHeight, RHeight)+1;

递归的递推关系有了，关键是找到递归的起始条件或者理解为终止条件。这里使用的思想是后序遍历（先遍历左右子树再处理结论），联系二叉树的后序遍历算法，进行改编。显然if(root==null)时:max=0;height=0;

总结：设计一个递归函数，输入根结点root，求出这棵二叉树的最大距离maxLength和高度length并返回。递推关系为：

maxLength= Math.max(LMax,RMax,(LHeight+RHeight+1))；

height=Math.max(LHeight, RHeight)+1

边界条件为：

if(root==null) return max=0;height=0;

在Java中不能分开返回2个值，因此要将2个值整合成为一个数组进行返回即可

public class LongestDistance {
    public int findLongest(TreeNode root) {
        // write code here
        int[] lenAndHei=get(root);
        return lenAndHei[0];
    }
    
    public int[] get(TreeNode root){//递归求根为root的最大距离和高度
        int[] lenAndHei=new int[2];
        if(root==null){
            lenAndHei[0]=lenAndHei[1]=0;
            return lenAndHei;
        }
        
        //左子树的最大距离和高度
        int[] left=get(root.left);
        int leftLen=left[0];
        int leftHei=left[1];
        
        //右子树的最大距离和高度
        int[] right=get(root.right);
        int rightLen=right[0];
        int rightHei=right[1];
        
        //当前树的最大距离和高度
        lenAndHei[0]=Math.max((Math.max(leftLen,rightLen)),(leftHei+rightHei+1));
        lenAndHei[1]=Math.max(leftHei,rightHei)+1;
        
        return lenAndHei;
    }
}

(4)

题目：

有一棵二叉树，其中所有节点的值都不一样,找到含有节点最多的搜索二叉子树,并返回这棵子树的头节点.给定二叉树的头结点root，请返回所求的头结点,若出现多个节点最多的子树，返回头结点权值最大的。

思路：

题目(3)中每次递归调用时需要得到2个信息（该子树的最大长度，该子树的高度）并将这2个信息组成数组进行返回，因此每次递归调用时先接收上次调用返回的数组，然后进行处理，处理完的结果放入到一个新的数组中再返回这个数组，注意，(3)中需要收集返回的2个信息都是int类型的，因此可以形成int[]数组进行返回；

本题中由于业务逻辑更加复杂，每一次递归调用时需要利用的信息有4个，同时递归方法执行结束后返回的信息也有4个（

当前子树的最大二叉搜索子树的根结点TreeNode，

最大搜索子树的结点数目int，

当前子树的最小值int，

当前子树的最大值int）

由于这4个信息不是同一类型的，因此不能组成一个数组进行返回，所以对于TreeNode的信息，依然可以直接返回，即令该递归函数的返回值是TreeNode，对于其他的3个int类型的参数

TreeNodelnode=postOrder(root.left,res);

intlmax=res[0];

intlmin=res[1];

intlnum=res[2];

TreeNodernode= postOrder(root.right,res);

intrmax=res[0];

intrmin=res[1];

intrnum=res[2];

例如，上面的res数组可以是临时创建的，也可以是使用的成员变量数组，反正认为在TreeNode lnode=postOrder(root.left,res);调用结束后res就已经被赋值了，于是就可以取出res中的值进行使用了。Res数组可以重复使用，因为res传入给递归函数只是作为一个容器来让方法填充数据的。

本题的业务逻辑：

要求以root为根的二叉树中的最大搜索二叉子树的根结点，以root，root的左结点，root的右结点这个基础结构来分析怎么求二叉子树的最大搜索二叉树。

显然以root为根的二叉树的最大搜索子树只可能来自2中情况：

情况1：当root左子树root.left上的最大搜索子树就是left结点，并且root右子树上root.right上的最大搜索子树就是right结点时，并且left子树上的最大值<root.val<right子树上的最小值，此时root结点就是这棵树的最大搜索子树的根结点，返回root。

此时注意一种特殊情况，如果root的某一个子节点不存在，例如当左结点不存在时，如果上面的条件依旧满足，即right就是最大搜索子树，且root.val<right，那么此时的最大搜索子树就是right子树加上结点root；同理当right不存在，且left子树就是左结点的最大搜索子树并且left<root.val，那么此时的最大搜索子树就是left子树加上root结点，这种情况应该作为left，right都存在的特殊情况一起考虑进去，直接返回root结点，因此采取的巧妙的策略就是当root==null时，令该子树的结点数目为0，最小值为Integer.MAX_VALUE，于是显然大于root结点；令最小值为Integer.MIN_VALUE，于是显然小于root结点，并且返回null最为最大搜索子树的根结点。此时必然满足情况1的判断条件，于是会返回root作为搜索子树的根结点。

情况2： 除此之外的情况都说明 最大搜索子树只可能只出现在一边 在root的左子树left或者右子树right上而不可能跨越root的两边组成一棵最大搜索树。并且已知左子树left上面搜索子树的根结点root1，其结点数目为n1；右子树right上面搜索子树的结点为right,其结点数为n2；因此比较n1与n2的大小即可，取较大者对应的根结点进行返回即可。

public class MaxSubtree {
    public TreeNode getMax(TreeNode root) {
        // write code here
        if(root==null) return null;
        int[] res=new int[3];
        TreeNode searchNode=get(root,res);
        return searchNode;
    }
    
    public TreeNode get(TreeNode root,int[] res){//res[0]节点数目，res[1]root为根的树的最小值，res[2]root为根的树的最大值
        if(root==null){
            res[0]=0;
            res[1]=Integer.MAX_VALUE;
            res[2]=Integer.MIN_VALUE;
            return null;
        }
        
        //左子树
        int[] left=new int[3];
        TreeNode leftNode=get(root.left,left);//递归左右子树
        
        //右子树
        int[] right=new int[3];
        TreeNode rightNode=get(root.right,right);
        
        //判断两种情况下的最大搜索树
        //情况一
        if(leftNode==root.left&&rightNode==root.right&&left[2]<root.val&&root.val<right[1]){
            //leftNode rightNode分别为root的左右孩子，且左孩子的最大值<root.val<右孩子的最小值（无重复值），此时root就是最大搜索树
            res[0]=left[0]+right[0]+1;
            //注意这里不能这样写,因为要考虑左右子树有一侧为null的情况。
            /*
            res[1]=left[1];//最小值=左孩子的最小值
            res[2]=right[2];//最大值=右孩子的最大值
            */
            res[1]=Math.min(left[1],root.val);//左子树可能为空
            res[2]=Math.max(right[2],root.val);//右子树可能为空
            return root;
        }
        
        //情况二：节点多的子树为root为根的最大搜索子树，最大搜索子树来自一边
        res[0]=Math.max(left[0],right[0]);
        res[1]=Math.min(Math.min(left[1],right[1]),root.val);//root为根的子树的最小值，不是最大搜索树的最小值
        res[2]=Math.max(Math.max(left[2],right[2]),root.val);//树root的最大值
        
        return left[0]>right[0]?leftNode:rightNode;
    }
}