1385：重建二叉树 @jobdu

思路很清晰，但是很容易就写错，特别是在写递归的参数时！为了避免混淆，我新建了多个临时变量来表示，这样会看的清楚一些，免得绕进去了！

题目1385：重建二叉树

时间限制：1 秒

内存限制：32 兆

特殊判题：否

提交：1574

解决：517

题目描述：

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并输出它的后序遍历序列。

输入：

输入可能包含多个测试样例，对于每个测试案例，

输入的第一行为一个整数n(1<=n<=1000)：代表二叉树的节点个数。

输入的第二行包括n个整数(其中每个元素a的范围为(1<=a<=1000))：代表二叉树的前序遍历序列。

输入的第三行包括n个整数(其中每个元素a的范围为(1<=a<=1000))：代表二叉树的中序遍历序列。

输出：

对应每个测试案例，输出一行：

如果题目中所给的前序和中序遍历序列能构成一棵二叉树，则输出n个整数，代表二叉树的后序遍历序列，每个元素后面都有空格。

如果题目中所给的前序和中序遍历序列不能构成一棵二叉树，则输出”No”。

样例输入：

81 2 4 7 3 5 6 84 7 2 1 5 3 8 681 2 4 7 3 5 6 84 1 2 7 5 3 8 6

样例输出：

7 4 2 5 8 6 3 1 No

重点是这幅图！要弄清楚index的变化关系！

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;


public class S6 {

	public static void main(String[] args) throws FileNotFoundException {
		BufferedInputStream in = new BufferedInputStream(new FileInputStream("S6.in"));
        System.setIn(in);
		Scanner cin = new Scanner(System.in);
		
		while (cin.hasNextInt()) {
			List<Integer> preorder = new ArrayList<Integer>();
			List<Integer> inorder = new ArrayList<Integer>();
			int size = cin.nextInt();
			for(int i=0; i<size; i++){
				preorder.add(cin.nextInt());
			}
			for(int i=0; i<size; i++){
				inorder.add(cin.nextInt());
			}
			
//			System.out.println(preorder);
//			System.out.println(inorder);
			TreeNode root = rebuild(preorder, inorder, 0, preorder.size()-1, 0, inorder.size()-1);
			List<Integer> postorderList = new ArrayList<Integer>();
			postorder(root, postorderList);
			if(postorderList.size() == preorder.size()){
				for (Integer integer : postorderList) {
					System.out.print(integer + " ");
				}
				System.out.println();
			}else{
				System.out.println("No");
			}
			
//			inorder(root);
		}
	}
	
	public static TreeNode rebuild(List<Integer> preorder, List<Integer> inorder, int preorderStart, int preorderEnd, int inorderStart, int inorderEnd){
		int rootVal = preorder.get(preorderStart);
		int rootInorder = -1;
		for(int i=inorderStart; i<=inorderEnd; i++){
			if(inorder.get(i) == rootVal){
				rootInorder = i;
				break;
			}
		}
		if(rootInorder == -1){
			return null;
		}
		
		TreeNode root = new TreeNode(rootVal);
		int leftSize = rootInorder - inorderStart;
		int leftPreorderStart = preorderStart+1;
		int leftPreorderEnd = preorderStart + leftSize;
		int leftInorderStart = inorderStart;
		int leftInorderEnd = rootInorder-1;
		if(leftSize > 0){
			root.left = rebuild(preorder, inorder, leftPreorderStart, leftPreorderEnd, leftInorderStart, leftInorderEnd);
		}
		
		int rightPreorderStart = leftPreorderEnd+1;
		int rightPreorderEnd = preorderEnd;
		int rightInorderstart = rootInorder+1;
		int rightInorderEnd = inorderEnd;
		if(leftSize < preorderEnd-preorderStart){
			root.right = rebuild(preorder, inorder, rightPreorderStart, rightPreorderEnd, rightInorderstart, rightInorderEnd);
		}
		
		return root;
	}
	
	public static void inorder(TreeNode root){
		if(root != null){
			inorder(root.left);
			System.out.print(root.val + " ");
			inorder(root.right);
		}
	}
	
	public static void postorder(TreeNode root, List<Integer> postorderList){
		if(root != null){
			postorder(root.left, postorderList);
			postorder(root.right, postorderList);
			postorderList.add(root.val);
		}
	}
	
	static class TreeNode{
		int val;
		TreeNode left;
		TreeNode right;
		public TreeNode(int val){
			this.val = val;
		}
	}
}