二叉树递归练习

（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;    }}