Description:
Return any binary tree that matches the given preorder and postorder traversals.
Values in the traversals pre and post are distinct positive integers.
Example 1:
Input: pre = [1,2,4,5,3,6,7], post = [4,5,2,6,7,3,1]
Output: [1,2,3,4,5,6,7]
Note:
- 1 <= pre.length == post.length <= 30
- pre[] and post[] are both permutations of 1, 2, …, pre.length.
- It is guaranteed an answer exists. If there exists multiple answers, you can return any of them.
Analysis:
The key point of the problem is to figure out the intervals of indexes of left subtree and right subtree in pre
and post
respectively. Here we use L
to denote the number of nodes in the left subtree. Then we can get the following graph:
As the following graph show, traverse the post
until an element that is equal to pre[1]
is found, this element represents the root node of the left subtree in post
, then we can obtain the value of L
. We can use a recursion to apply this strategy to construct the root node, left subtree and right subtree.
Code:
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public TreeNode constructFromPrePost(int[] pre, int[] post) {
if(pre.length == 0) {
return null;
}else if(pre.length == 1) {
return new TreeNode(pre[0]);
}else{
TreeNode root = new TreeNode(pre[0]);
int N = pre.length;
int L = 0;
for(int i = 0; i < N; i++) {
L += 1;
if(post[i] == pre[1]) {
break;
}
}
root.left = constructFromPrePost(Arrays.copyOfRange(pre, 1, L+1), Arrays.copyOfRange(post, 0, L));
root.right = constructFromPrePost(Arrays.copyOfRange(pre, L+1, N), Arrays.copyOfRange(post, L, N-1));
return root;
}
}
}