Given two integer arrays, preorder
and postorder
where preorder
is the preorder traversal of a binary tree of distinct values and postorder
is the postorder traversal of the same tree, reconstruct and return the binary tree.
If there exist multiple answers, you can return any of them.
Example 1:
Input: preorder = [1,2,4,5,3,6,7], postorder = [4,5,2,6,7,3,1] Output: [1,2,3,4,5,6,7]
Example 2:
Input: preorder = [1], postorder = [1] Output: [1]
Constraints:
1 <= preorder.length <= 30
1 <= preorder[i] <= preorder.length
- All the values of
preorder
are unique. postorder.length == preorder.length
1 <= postorder[i] <= postorder.length
- All the values of
postorder
are unique. - It is guaranteed that
preorder
andpostorder
are the preorder traversal and postorder traversal of the same binary tree.
【C++】
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
Recursive Solution
class Solution {
int pre = 0, post = 0;
public:
TreeNode* constructFromPrePost(vector<int>& preorder, vector<int>& postorder) {
TreeNode* root = new TreeNode(preorder[pre++]);
if (postorder[post] != root->val) {
root->left = constructFromPrePost(preorder, postorder);
}
if (postorder[post] != root->val) {
root->right = constructFromPrePost(preorder, postorder);
}
post++;
return root;
}
};
Iterative Solution
class Solution {
public:
TreeNode* constructFromPrePost(vector<int>& preorder, vector<int>& postorder) {
vector<TreeNode*> s;
s.push_back(new TreeNode(preorder[0]));
for (int i = 1, j = 0; i < preorder.size(); ++i) {
TreeNode* node = new TreeNode(preorder[i]);
while (s.back()->val == postorder[j]) {
s.pop_back();
j++;
}
if (s.back()->left == NULL) s.back()->left = node;
else s.back()->right = node;
s.push_back(node);
}
return s[0];
}
};
【Java】
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
Recursive
class Solution {
private int pre = 0;
private int post = 0;
public TreeNode constructFromPrePost(int[] preorder, int[] postorder) {
TreeNode root = new TreeNode(preorder[pre++]);
if (root.val != postorder[post]) {
root.left = constructFromPrePost(preorder, postorder);
}
if (root.val != postorder[post]) {
root.right = constructFromPrePost(preorder, postorder);
}
post++;
return root;
}
}
Iterative
class Solution {
public TreeNode constructFromPrePost(int[] preorder, int[] postorder) {
Deque<TreeNode> s = new LinkedList<>();
s.offerLast(new TreeNode(preorder[0]));
for (int i = 1, j = 0; i < preorder.length; i++) {
TreeNode node = new TreeNode(preorder[i]);
while (s.peekLast().val == postorder[j]) {
s.pollLast();
j++;
}
if (s.peekLast().left == null) {s.peekLast().left = node;}
else {s.peekLast().right = node;}
s.offerLast(node);
}
return s.peekFirst();
}
}