由先序中序求二叉树

我写的有个地方没想到，就是在中序求出左子树的节点后，又从先序求左子树的节点个数，其实两个是一样的。。。。

复杂程序

package sword;

import java.util.LinkedList;
import java.util.Queue;

public class tmp {

	public static void main(String[] args) {
		int[] pre = { 1, 2, 3, 4 };
		int[] in = { 4, 3, 2, 1 };
		TreeNode tNode = reConstructBinaryTree(pre, in);
		Queue<TreeNode> que = new LinkedList<TreeNode>();
		que.add(tNode);
		while (!que.isEmpty()) {
			TreeNode tmp = que.remove();
			System.out.println(tmp.val);
			if (tmp.left != null)
				que.add(tmp.left);
			if (tmp.right != null)
				que.add(tmp.right);
		}
	}

	public static TreeNode reConstructBinaryTree(int[] pre, int[] in) {
		int len = pre.length;
		if (pre.length == 0 || pre.length != in.length)
			return null;
		return digui(pre, in, 0, len - 1, 0, len - 1);
	}

	public static TreeNode digui(int[] pre, int[] in, int start, int end, int left, int right) {
		int len = pre.length;
		if (start >= len || end < 0 || left >= len || right < 0)
			return null;
		TreeNode tn = new TreeNode(pre[start]);
		if (start < end) {
			int i = left;
			for (; i <= right && in[i] != pre[start]; i++)
				;
			int j = start + 1;
			for (; j <= end; j++) {
				boolean flag = false;
				for (int k = 0; k < i; k++) {
					if (pre[j] == in[k])
						flag = true;
				}
				if (!flag)
					break;
			}
			tn.left = digui(pre, in, start + 1, j - 1, left, i - 1);
			tn.right = digui(pre, in, j, end, i + 1, right);
			return tn;
		}
		if (start == end)
			return tn;
		return null;
	}

	public static class TreeNode {
		int val;
		TreeNode left;
		TreeNode right;

		TreeNode(int x) {
			val = x;
		}
	}
}

简化的代码：

public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
       if(pre.length == 0||in.length == 0){
            return null;
        }
        TreeNode node = new TreeNode(pre[0]);
        for(int i = 0; i < in.length; i++){
            if(pre[0] == in[i]){
                node.left = reConstructBinaryTree(Arrays.copyOfRange(pre, 1, i+1), Arrays.copyOfRange(in, 0, i));
                node.right = reConstructBinaryTree(Arrays.copyOfRange(pre, i+1, pre.length), Arrays.copyOfRange(in, i+1,in.length));
            }
        }
        return node;
    }
}