105. Construct Binary Tree from Preorder and Inorder Traversal
树的题，要记住，树的题一般都有递归做法。。
对于preOrder来说，先遍历ROOT，然后往左，再往右，只能保证第一个是ROOT，其余不一定。
我们就先得到ROOT。
对于inOrder来说，如果找到了ROOT，那么遍历ROOT之前的所有Node都是左边的，之后都是右边的。
所以我们通过preOrder得到ROOT，然后在inOrder里找到ROOT，因为没有重复的，所以找到那个数就是ROOT。
在
然后0-(ROOT-1)作为左边子树再recursion
ROOT+1到尾是右边子树
构建ROOT.LEFT = ...
ROOT.RIGHT =
递归
return root 就行了。。
public TreeNode buildTree(int[] preorder, int[] inorder) {
if(preorder.length == 0) return null;
int rootIndex = 0;
int tempRootVal = preorder[rootIndex];
int tempIndex = 0;
while(inorder[tempIndex] != tempRootVal)
{
tempIndex++;
}
TreeNode root = new TreeNode(tempRootVal);
int[] newPre = Arrays.copyOfRange(preorder,rootIndex+1,tempIndex+1);
int[] newIn = Arrays.copyOfRange(inorder,rootIndex,tempIndex);
root.left = buildTree(newPre,newIn);
newPre = Arrays.copyOfRange(preorder,tempIndex+1,preorder.length);
newIn = Arrays.copyOfRange(inorder,tempIndex+1,inorder.length);
root.right = buildTree(newPre,newIn);
return root;
}
代码比较简单，搞好INDEX就没问题了。。可以写在纸上。
一开始从尾找，比较麻烦，如果用这种思路，不如从头找。
然后好像可以用STACK来做 还没看 二刷看看。。
二刷。
每次找ROOT，然后肥城两边就行了。
public class Solution
{
public TreeNode buildTree(int[] pre, int[] in)
{
if(pre.length == 0) return null;
if(pre.length == 1) return new TreeNode(pre[0]);
TreeNode root = new TreeNode(pre[0]);
int temp = 0;
for(int i = 0; i < in.length;i++)
{
if(in[i] == root.val)
{
temp = i;
break;
}
}
int[] P = Arrays.copyOfRange(pre,1,temp+1);
int[] I = Arrays.copyOfRange(in,0,temp);
root.left = buildTree(P,I);
P = Arrays.copyOfRange(pre,temp+1,pre.length);
I = Arrays.copyOfRange(in,temp+1,in.length);
root.right = buildTree(P,I);
return root;
}
}
听说有STACK的做法。。
得用MAP来对应 inOrder里INDEX和VAL的位置。
二刷
preOrder的第一个肯定是ROOT，然后从inOrder找这个ROOT的val，然后找到位置的左边就是LEFT，右边是RIGHT。 对应preOrder从第二个开始同样长度是左边，剩下的是右边。。
一刷是新建了Array作为新的pre/in order数组，很占空间，这次尝试记录他们的起始和结束坐标位置。
做起来费了点事。。
一开始犯了个错误，在inOrder中寻找ROOT的时候，从index = 1开始找，是不对的，应该从index = 0。
比如inOrder [4,7,6]
preOrder [4,6,7]
ROOT是4，在inOrder里index = 0就是了。。
public class Solution {
public TreeNode buildTree(int[] preorder, int[] inorder) {
return divide(preorder, inorder, 0, preorder.length - 1, 0, preorder.length - 1);
}
public TreeNode divide(int[] pre, int[] in,
int preL, int preR, int inL, int inR) {
if (preR < preL) return null;
if (preR == preL) return new TreeNode(pre[preL]);
TreeNode res = new TreeNode(pre[preL]);
int i = 0;
while (in[inL + i] != pre[preL]) i ++;
res.left = divide(pre, in, preL + 1, preL + i, inL, inL + i - 1);
res.right = divide(pre, in, preL + i + 1, preR, inL + i + 1, inR);
return res;
}
}
一般树的都可以迭代和递归，刚才是递归。
迭代我思考了一下，确实不会。。。。。。。
