九度Online Judge | 剑指Offer | 重建二叉树

题目描述：

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{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”。

样例输入：

8

1 2 4 7 3 5 6 8

4 7 2 1 5 3 8 6

8

1 2 4 7 3 5 6 8

4 1 2 7 5 3 8 6

样例输出：

7 4 2 5 8 6 3 1 

No

分析：

递归的应用，重建二叉树采用递归，后续遍历采用递归。递归用起来思路清晰，但性能确实不敢恭维。此外，这道题与leetcode的重建二叉树区别在于，要判断给出的先序遍历和中序遍历是否有误。只要判断先序数组索引为p的节点是否在中序数组索引start至end中出现，未出现，则有误，具体见代码。

个人解答：

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

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

	private int[] preOrder;
	private int[] inOrder;
	private boolean correct = true;

	public RebuildBinaryTree(int[] preOrder, int[] inOrder) {
		this.preOrder = preOrder;
		this.inOrder = inOrder;
	}

	private TreeNode rebuild(int p, int start, int end) {
		if (start > end) {
			return null;
		}
		for (int i = start; i <= end; ++i) {
			if (preOrder[p] == inOrder[i]) {
				TreeNode left = rebuild(p + 1, start, i - 1);
				if (!correct) {
					return null;
				}
				TreeNode right = rebuild(p + i - start + 1, i + 1, end);
				if (!correct) {
					return null;
				}
				TreeNode root = new TreeNode(inOrder[i]);
				root.left = left;
				root.right = right;
				return root;
			}
		}
		correct = false;
		return null;
	}

	private void postOrder(TreeNode root) {
		if (root == null) {
			return;
		}
		postOrder(root.left);
		postOrder(root.right);
		System.out.print(root.val + " ");
	}

	public static void main(String[] args) {
		Scanner reader = new Scanner(System.in);
		while (reader.hasNextInt()) {
			int n = reader.nextInt();
			int[] preOrder = new int[n];
			int[] inOrder = new int[n];
			for (int i = 0; i < n; ++i) {
				preOrder[i] = reader.nextInt();
			}
			for (int i = 0; i < n; ++i) {
				inOrder[i] = reader.nextInt();
			}

			RebuildBinaryTree reBuilder = new RebuildBinaryTree(preOrder,
					inOrder);
			TreeNode root = reBuilder.rebuild(0, 0, n - 1);
			if (!reBuilder.correct) {
				System.out.println("No");
			} else {
				reBuilder.postOrder(root);
				System.out.println();
			}
		}
		reader.close();
	}
}