【leetcode】Array——Construct Binary Tree from Preorder and Inorder Traversal（105）

题目：

Given preorder and inorder traversal of a tree, construct the binary tree.

Note:

You may assume that duplicates do not exist in the tree.
思路：使用递归。

preorder[0]是整个tree的root，在inerder中定位root，左侧的是leftTree或者leftchild，右侧的是rightTree或者rightchild。

通过root在preorder中的位置以及左右树的节点数，可以在preorder中分别定位各自的子树的root。

举个栗子：

preorder：A B D E C F inorder: D B E A F C

root为A，inorder定位A后，划分两部分，左树是D B E，右树是F C，分别递归。

左树的root可以通过preorder定位：原rootIndex+1即为B，再把左树划分。

右树的root在preorder的位置：原rootIndex+(左侧树的节点数)+1

递归的过程中，会维护inorder两个index：left和right，left和right之间构成一个子树，带解析。

左/右树的节点数，就是 left和right之间被root划分后两侧的长度。（详细见代码理解）

代码：

public class Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal {
public int [] preorder;
public int [] inorder;

public TreeNode buildTree(int[] preorder, int[] inorder) {
this.preorder = preorder;
this.inorder = inorder;
if(preorder==null||preorder.length==0)
return null;
TreeNode root = new TreeNode(preorder[0]);
divideInorder(preorder[0], 0, root ,0,inorder.length-1);
return root;
}

private void divideInorder(int rootInt,int rootIntIndex,TreeNode root,int left,int right){
for(int i=left;i<=right;i++){
if(inorder[i]==rootInt){
if(i>left){
int leftRootInt = preorder[rootIntIndex+1];
TreeNode leftNode = new TreeNode(leftRootInt);
root.left=leftNode;
if(left+1<i){
//存在left子树
divideInorder(leftRootInt,rootIntIndex+1,leftNode,left,i-1);
}
}
if(i<right){
int rightRootInt = preorder[rootIntIndex+i-left+1];
TreeNode rightNode = new TreeNode(rightRootInt);
root.right=rightNode;
if(i+1<right){
//存在right子树
divideInorder(rightRootInt, rootIntIndex+i-left+1, rightNode, i+1, right);
}
}
}
}

}
}

思路（改进）：用HashMap存放inorder信息，这样在preorder中定位根节点后可以直接查询map就可知root在inorder中的位置，不用再次遍历。

public class Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal {
public int [] preorder;
public Map<Integer,Integer> inorderMap = new HashMap<>();

public TreeNode buildTree(int[] preorder, int[] inorder) {
this.preorder = preorder;
if(preorder==null||preorder.length==0)
return null;
for(int i=0;i<inorder.length;i++)
inorderMap.put(inorder[i], i);

TreeNode root = new TreeNode(preorder[0]);
divideInorder(preorder[0], 0, root ,0,inorder.length-1);
return root;
}

private void divideInorder(int rootInt,int rootIntIndex,TreeNode root,int left,int right){
int i = inorderMap.get(rootInt);
if(i>left){
int leftRootInt = preorder[rootIntIndex+1];
TreeNode leftNode = new TreeNode(leftRootInt);
root.left=leftNode;
if(left+1<i){
//存在left子树
divideInorder(leftRootInt,rootIntIndex+1,leftNode,left,i-1);
}
}
if(i<right){
int rightRootInt = preorder[rootIntIndex+i-left+1];
TreeNode rightNode = new TreeNode(rightRootInt);
root.right=rightNode;
if(i+1<right){
//存在right子树
divideInorder(rightRootInt, rootIntIndex+i-left+1, rightNode, i+1, right);
}
}

}
}