根据前中后中任意两种的任意组合重构二叉树-Java实现

以下的代码均通过力扣的测试，仅供初学者进行参考，全是一种模版形式，以下的示例操作的也是同一棵树。

1. 根据前序和后序遍历构造二叉树
2. 从前序与中序遍历序列构造二叉树
3. 从中序与后序遍历序列构造二叉树

    3
   / \
  9  20
    /  \
   15   7

1 根据前序和后序遍历构造二叉树
题目描述：返回与给定的前序和后序遍历匹配的任何二叉树。
pre 和 post 遍历中的值是不同的正整数。
示例：
输入：pre = [1,2,4,5,3,6,7], post = [4,5,2,6,7,3,1]
输出：[1,2,3,4,5,6,7]

class Solution {
    public TreeNode constructFromPrePost(int[] pre, int[] post) {return helper(pre,0,pre.length-1,post,0,post.length-1);
    }
	private TreeNode helper(int[] pre, int startPre, int endPre, int[] post, int startPost, int endPost) {
		if(startPre>endPre || startPost>endPost) {
			return null;
		}
		TreeNode root=new TreeNode(pre[startPre]);
		if(startPre==endPre) {
			return root;
		}
		int start=0;
		for(;start<endPost;start++) {
			if(pre[startPre+1]==post[start]) {
				break;
			}
		}
		root.left=helper(pre,startPre+1,startPre+1+start-startPost,post,startPost,start);
		root.right=helper(pre,startPre+2+start-startPost,endPre,post,start+1,endPost-1);
		return root;
	}
}

2. 从前序与中序遍历序列构造二叉树
根据一棵树的前序遍历与中序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。
例如，给出
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
return helper2(preorder,0,preorder.length-1,inorder,0,inorder.length-1);
    }
	private TreeNode helper2(int[] preorder, int startPre, int endPre, int[] inorder, int startIn, int endIn) {
		if(startPre>endPre || startIn>endIn) {
			return null;
		}
		TreeNode root=new TreeNode(preorder[startPre]);
		if(startPre==endPre) {
			return root;
		}
		int start=0;
		for(;start<endIn;start++) {
			if(preorder[startPre]==inorder[start]) {
				break;
			}
		}
		root.left=helper2(preorder,startPre+1,startPre+start-startIn,inorder,startIn,start-1);
		root.right=helper2(preorder,startPre+start-startIn+1,endPre,inorder,start+1,endIn);
		return root;
	}
}

3. 从中序与后序遍历序列构造二叉树
根据一棵树的中序遍历与后序遍历构造二叉树。
注意:
你可以假设树中没有重复的元素。
例如，给出
中序遍历 inorder = [9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]

class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
         if(inorder.length == 0) return null;
	        return rebuildBT(inorder,0,inorder.length-1,postorder,0,postorder.length-1);
		 }
		private TreeNode rebuildBT(int[] inOrder, int startIn, int endIn, int[] postorder, int startPost, int endPost){
	        if(endIn < startIn || endPost < startPost) return null;
	        TreeNode root = new TreeNode(postorder[endPost]);
	        int start = startIn;
	        while(inOrder[start] != postorder[endPost]){
	            start++;
	        }
	        root.left = rebuildBT(inOrder, startIn, start - 1, postorder ,startPost, start + startPost - startIn - 1);
	        root.right= rebuildBT(inOrder, start + 1, endIn, postorder, start + startPost - startIn, endPost - 1);
	        return root;
	    }
}