leetcode-105- 从前序与中序遍历序列构造二叉树(construct binary tree from preorder and inorder traversal)-java

题目及测试

package pid105;


/*从前序与中序遍历序列构造二叉树

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

注意:
你可以假设树中没有重复的元素。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]

返回如下的二叉树：

    3
   / \
  9  20
    /  \
   15   7





}*/
public class main {
	
	public static void main(String[] args) {
		int[] ito=new int[]{3,9,20,15,7};
		int[] ito2=new int[]{9,3,15,20,7};
		//Object[] x=new Object[]{3,9,20,null,null,15,7};	
		//BinaryTree tree=new BinaryTree(x);
		//tree.printTree(tree.root);
		test(ito,ito2);
		
		
	}
		 
	private static void test(int[] ito,int[] ito2) {
		Solution solution = new Solution();
		TreeNode rtn;
		for(int now:ito){
			System.out.print(now+" ");
		}
		System.out.println();
		for(int now:ito2){
			System.out.print(now+" ");
		}
		System.out.println();
		long begin = System.currentTimeMillis();
		rtn = solution.buildTree(ito,ito2);//执行程序
		long end = System.currentTimeMillis();		
		System.out.println("rtn=" );
		new BinaryTree(1).printTree(rtn);
		System.out.println();
		System.out.println("耗时：" + (end - begin) + "ms");
		System.out.println("-------------------");
	}

}

解法1（成功，31ms，较慢）

从前序遍历可以得到该段的root，从中序遍历找到root，root的左右是root的左右节点，就可以按这个方法递归出这个节点的左右子节点。

生成左子树和右子树就可以递归的进行了。

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int length=preorder.length;
        if(length==0||length!=inorder.length){
        	return null;
        }
    	return buildTreeNodeByPreAndInOrder(preorder, inorder, 0, length-1, 0, length-1);
    }	
	
	public TreeNode buildTreeNodeByPreAndInOrder(int[] preorder, int[] inorder,
			int preFirst,int preLast,int inFirst,int inLast){
		// 先校验返回的是否为null
		if(preLast-preFirst<0){
			return null;
		}
		// 根据前序遍历，得到中间节点的值，并创建中间节点
		int midNum=preorder[preFirst];
		TreeNode result=new TreeNode(midNum);
		// 在中序遍历找到midNum的位置
		int inMid=0;
		for(int i=inFirst;i<=inLast;i++){
			if(inorder[i]==midNum){
				inMid=i;
				break;
			}
		}
		// 中间节点的左子树的长度为inMid-inFirst
		int leftSize=inMid-inFirst;
		// 右子树长度为inLast-inMid
		int RightSize=inLast-inMid;
		// 前序遍历，左子树范围为[preFirst+1,preFirst+leftSize],,右子树范围为[preFirst+leftSize+1,preLast]
		// 中序遍历，左子树范围为[inFirst,inMid-1],右子树范围为[inMid+1,inLast]
		result.left=buildTreeNodeByPreAndInOrder(preorder, inorder, preFirst+1, preFirst+leftSize, inFirst, inMid-1);
		result.right=buildTreeNodeByPreAndInOrder(preorder, inorder, preFirst+leftSize+1, preLast, inMid+1, inLast);				
		return result;
	}

 

解法2（成功，3ms，较快）

上述的做法有个缺点，每次都要去中序遍历中，查找中间节点的位置，因为数字不重复，可以将中序遍历放入hashmap，把中序遍历数组的每个元素的值和下标存起来，这样寻找根节点的位置就可以直接得到了。

	HashMap<Integer, Integer> mapInOrder = null;
	
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int length=preorder.length;
        if(length==0||length!=inorder.length){
        	return null;
        }
        mapInOrder = new HashMap<Integer, Integer>(length);
        for(int i=0;i<length;i++) {
        	mapInOrder.put(inorder[i], i);
        }
    	return buildTreeNodeByPreAndInOrder(preorder, inorder, 0, length-1, 0, length-1);
    }	
	
	public TreeNode buildTreeNodeByPreAndInOrder(int[] preorder, int[] inorder,
			int preFirst,int preLast,int inFirst,int inLast){
		// 先校验返回的是否为null
		if(preLast-preFirst<0){
			return null;
		}
		// 根据前序遍历，得到中间节点的值，并创建中间节点
		int midNum=preorder[preFirst];
		TreeNode result=new TreeNode(midNum);
		// 在中序遍历找到midNum的位置
		int inMid=mapInOrder.get(midNum);
		// 中间节点的左子树的长度为inMid-inFirst
		int leftSize=inMid-inFirst;
		// 右子树长度为inLast-inMid
		int RightSize=inLast-inMid;
		// 前序遍历，左子树范围为[preFirst+1,preFirst+leftSize],,右子树范围为[preFirst+leftSize+1,preLast]
		// 中序遍历，左子树范围为[inFirst,inMid-1],右子树范围为[inMid+1,inLast]
		result.left=buildTreeNodeByPreAndInOrder(preorder, inorder, preFirst+1, preFirst+leftSize, inFirst, inMid-1);
		result.right=buildTreeNodeByPreAndInOrder(preorder, inorder, preFirst+leftSize+1, preLast, inMid+1, inLast);				
		return result;
	}

解法3（别人的）

用pre变量保存当前要构造的树的根节点，从根节点开始递归的构造左子树和右子树，in变量指向当前根节点可用数字的开头，然后对于当前pre有一个停止点stop，从in到stop表示要构造的树当前的数字范围。

public TreeNode buildTree(int[] preorder, int[] inorder) {
    return buildTreeHelper(preorder,  inorder, (long)Integer.MAX_VALUE + 1);
}
int pre = 0;
int in = 0;
private TreeNode buildTreeHelper(int[] preorder, int[] inorder, long stop) {
    //到达末尾返回 null
    if(pre == preorder.length){
        return null;
    }
    //到达停止点返回 null
    //当前停止点已经用了，in 后移
    if (inorder[in] == stop) {
        in++;
        return null;
    }
    int root_val = preorder[pre++];
    TreeNode root = new TreeNode(root_val);   
    //左子树的停止点是当前的根节点
    root.left = buildTreeHelper(preorder,  inorder, root_val);
    //右子树的停止点是当前树的停止点
    root.right = buildTreeHelper(preorder, inorder, stop);
    return root;
}

      3
    /   \
   9     7
  / \
 20  15
 
前序遍历数组和中序遍历数组
preorder = [ 3, 9, 20, 15, 7 ]
inorder = [ 20, 9, 15, 3, 7 ]   
p 代表 pre，i 代表 in，s 代表 stop

首先构造根节点为 3 的树，可用数字是 i 到 s
s 初始化一个树中所有的数字都不会相等的数，所以代码中用了一个 long 来表示
3, 9, 20, 15, 7 
^  
p
20, 9, 15, 3, 7
^              ^
i              s

考虑根节点为 3 的左子树，                考虑根节点为 3 的树的右子树，
stop 值是当前根节点的值 3                只知道 stop 值是上次的 s
新的根节点是 9,可用数字是 i 到 s 
不包括 s
3, 9, 20, 15, 7                       3, 9, 20, 15, 7                
   ^                                    
   p
20, 9, 15, 3, 7                       20, 9, 15, 3, 7                     
^          ^                                         ^
i          s                                         s

递归出口的情况
3, 9, 20, 15, 7 
       ^  
       p
20, 9, 15, 3, 7
^    
i   
s   
此时 in 和 stop 相等，表明没有可用的数字，所以返回 null，并且表明此时到达了某个树的根节点，所以 i 后移。

总之他的思想就是，不再从中序遍历中寻找根节点的位置，而是直接把值传过去，表明当前子树的结束点。不过总感觉还是没有 get 到他的点，in 和 stop 变量的含义也是我赋予的，对于整个算法也只是勉强说通，大家有好的想法可以和我交流。