/**
 * 輸入某二叉樹的前序遍歷和中序遍歷的結果，請重建出該二叉樹。假設輸入的前序遍歷和中序
 * 遍歷的結果中都不含重複的數字。例如輸入前序遍歷序列{1,2,4,7,3,5,6,8}和中序遍歷序列
 * {4,7,2,1,5,3,8,6}，則重建二叉樹並返回。
 * 
 */
public class Test04 {
	public static TreeNode reConstructBinaryTree(int [] pre,int [] in) {
		
		 return construct(pre, 0, pre.length - 1, in, 0, in.length - 1);
	        
	    }
	/**
	 * 
	 * @param preorder 前序遍歷
     * @param ps       前序遍歷的開始位置
     * @param pe       前序遍歷的結束位置
     * @param inorder  中序遍歷
     * @param is       中序遍歷的開始位置
     * @param ie       中序遍歷的結束位置
	 * @return TreeNode 樹的根結點
	 * @exception 
	 */
	 public static TreeNode construct(int[] preorder, int ps, int pe, int[] inorder, int is, int ie) {

	        // 開始位置大於結束位置說明已經沒有需要處理的元素了
	        if (ps > pe) {
	            return null;
	        }
	        // 取前序遍歷的第一個數字，就是當前的根結點
	        int val = preorder[ps];
	        int index = is;
	        // 在中序遍歷的陣列中找根結點的位置
	        while (index <= ie && inorder[index] != val) {
	            index++;
	        }

	        // 如果在整個中序遍歷的陣列中沒有找到，說明輸入的引數是不合法的，丟擲異常
	        if (index > ie) {
	            throw new RuntimeException("Invalid input");
	        }

	        // 建立當前的根結點，並且為結點賦值
	        TreeNode node = new TreeNode(val);

	        // 遞迴構建當前根結點的左子樹，左子樹的元素個數：index-is+1個
	        // 左子樹對應的前序遍歷的位置在[ps+1, ps+index-is]
	        // 左子樹對應的中序遍歷的位置在[is, index-1]
	        node.left = construct(preorder, ps + 1, ps + index - is, inorder, is, index - 1);
	        // 遞迴構建當前根結點的右子樹，右子樹的元素個數：ie-index個
	        // 右子樹對應的前序遍歷的位置在[ps+index-is+1, pe]
	        // 右子樹對應的中序遍歷的位置在[index+1, ie]
	        node.right = construct(preorder, ps + index - is + 1, pe, inorder, index + 1, ie);

	        // 返回建立的根結點
	        return node;
	    }
	 
	//中序遍歷二叉樹
	  public static void printTree(TreeNode root) {
	      if (root != null) {
	          printTree(root.left);
	          System.out.print(root.val + " ");
	          printTree(root.right);
	      }

	  }

	  // 普通二叉樹
	  //              1
	  //           /     \
	  //          2       3
	  //         /       / \
	  //        4       5   6
	  //         \         /
	  //          7       8
	  private static void test1() {
	      int[] preorder = {1, 2, 4, 7, 3, 5, 6, 8};
	      int[] inorder = {4, 7, 2, 1, 5, 3, 8, 6};
	      TreeNode root = reConstructBinaryTree(preorder, inorder);
	      printTree(root);
	  }

	  // 所有結點都沒有右子結點
	  //            1
	  //           /
	  //          2
	  //         /
	  //        3
	  //       /
	  //      4
	  //     /
	  //    5
	  private static void test2() {
	      int[] preorder = {1, 2, 3, 4, 5};
	      int[] inorder = {5, 4, 3, 2, 1};
	      TreeNode root = reConstructBinaryTree(preorder, inorder);
	      printTree(root);
	  }

	  // 所有結點都沒有左子結點
	  //            1
	  //             \
	  //              2
	  //               \
	  //                3
	  //                 \
	  //                  4
	  //                   \
	  //                    5
	  private static void test3() {
	      int[] preorder = {1, 2, 3, 4, 5};
	      int[] inorder = {1, 2, 3, 4, 5};
	      TreeNode root = reConstructBinaryTree(preorder, inorder);
	      printTree(root);
	  }

	  // 樹中只有一個結點
	  private static void test4() {
	      int[] preorder = {1};
	      int[] inorder = {1};
	      TreeNode root = reConstructBinaryTree(preorder, inorder);
	      printTree(root);
	  }

	  // 完全二叉樹
	  //              1
	  //           /     \
	  //          2       3
	  //         / \     / \
	  //        4   5   6   7
	  private static void test5() {
	      int[] preorder = {1, 2, 4, 5, 3, 6, 7};
	      int[] inorder = {4, 2, 5, 1, 6, 3, 7};
	      TreeNode root = reConstructBinaryTree(preorder, inorder);
	      printTree(root);
	  }
	  public static void main(String[] args) {

	      test1();
	      System.out.println();
	      test2();
	      System.out.println();
	      test3();
	      System.out.println();
	      test4();
	      System.out.println();
	      test5();
	      System.out.println();

	  }
}

  //二叉樹結點
  class TreeNode {
      int val;
      TreeNode left;
      TreeNode right;
      TreeNode(int x) { val = x; }
  }