Skip to content

Commit ab085b9

Browse files
ifmagicifmagic
authored
feat: add solutions to lc problem: No.0889 (doocs#845)
No.0889.Construct Binary Tree from Preorder and Postorder Traversal
1 parent 7a736ae commit ab085b9

File tree

4 files changed

+207
-5
lines changed

4 files changed

+207
-5
lines changed

‎solution/0800-0899/0889.Construct Binary Tree from Preorder and Postorder Traversal/README.md

Lines changed: 74 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -46,6 +46,12 @@
4646

4747
<!-- 这里可写通用的实现逻辑 -->
4848

49+
**方法一：递归**
50+
51+
1. 以 preorder 的第一个元素或 postorder 的最后一个元素为根节点的值。
52+
2. 以 preorder 的第二个元素作为左子树的根节点，在 postorder 中找到该元素的索引 i，然后基于索引 i 可以计算出左右子树的长度。
53+
3. 最后基于左右子树的长度，分别划分出前序和后序遍历序列中的左右子树，递归构造左右子树即可。
54+
4955
<!-- tabs:start -->
5056

5157
### **Python3**
@@ -80,12 +86,78 @@ class Solution:
8086
return root
8187
```
8288

83-
### **Java**
89+
### **Go**
8490

8591
<!-- 这里可写当前语言的特殊实现逻辑 -->
8692

87-
```java
93+
```go
94+
/**
95+
* Definition for a binary tree node.
96+
* type TreeNode struct {
97+
* Val int
98+
* Left *TreeNode
99+
* Right *TreeNode
100+
* }
101+
*/
102+
func constructFromPrePost(preorder []int, postorder []int) *TreeNode {
103+
postMap := make(map[int]int)
104+
for index, v := range postorder {
105+
postMap[v] = index
106+
}
107+
var dfs func(prel, prer, postl, postr int) *TreeNode
108+
dfs = func(prel, prer, postl, postr int) *TreeNode {
109+
if prel > prer {
110+
return nil
111+
}
112+
root := &TreeNode{Val: preorder[prel]}
113+
if prel == prer {
114+
return root
115+
}
116+
leftRootIndex := postMap[preorder[prel+1]]
117+
leftLength := leftRootIndex - postl + 1
118+
root.Left = dfs(prel+1, prel+leftLength, postl, leftRootIndex)
119+
root.Right = dfs(prel+leftLength+1, prer, leftRootIndex+1, postr-1)
120+
return root
121+
}
122+
return dfs(0, len(preorder)-1, 0, len(postorder)-1)
123+
}
124+
```
88125

126+
### **C++**
127+
128+
```cpp
129+
/**
130+
* Definition for a binary tree node.
131+
* struct TreeNode {
132+
* int val;
133+
* TreeNode *left;
134+
* TreeNode *right;
135+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
136+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
137+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
138+
* };
139+
*/
140+
class Solution {
141+
public:
142+
unordered_map<int, int> postMap;
143+
TreeNode* constructFromPrePost(vector<int>& preorder, vector<int>& postorder) {
144+
for (int i = 0; i < postorder.size(); i++) {
145+
postMap[postorder[i]] = i;
146+
}
147+
return build(preorder, 0, preorder.size() - 1, postorder, 0, postorder.size() - 1);
148+
}
149+
150+
TreeNode* build(vector<int>& preorder, int prel, int prer, vector<int>& postorder, int postl, int postr) {
151+
if (prel > prer) return nullptr;
152+
TreeNode* root = new TreeNode(preorder[prel]);
153+
if (prel == prer) return root;
154+
int leftRootIndex = postMap[preorder[prel + 1]];
155+
int leftLength = leftRootIndex - postl + 1;
156+
root->left = build(preorder, prel + 1, prel + leftLength, postorder, postl, leftRootIndex);
157+
root->right = build(preorder, prel + leftLength + 1, prer, postorder, leftRootIndex + 1, postr - 1);
158+
return root;
159+
}
160+
};
89161
```
90162

91163
### **...**

‎solution/0800-0899/0889.Construct Binary Tree from Preorder and Postorder Traversal/README_EN.md

Lines changed: 71 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -70,10 +70,78 @@ class Solution:
7070
return root
7171
```
7272

73-
### **Java**
74-
75-
```java
73+
### **Go**
74+
75+
<!-- 这里可写当前语言的特殊实现逻辑 -->
76+
77+
```go
78+
/**
79+
* Definition for a binary tree node.
80+
* type TreeNode struct {
81+
* Val int
82+
* Left *TreeNode
83+
* Right *TreeNode
84+
* }
85+
*/
86+
func constructFromPrePost(preorder []int, postorder []int) *TreeNode {
87+
postMap := make(map[int]int)
88+
for index, v := range postorder {
89+
postMap[v] = index
90+
}
91+
var dfs func(prel, prer, postl, postr int) *TreeNode
92+
dfs = func(prel, prer, postl, postr int) *TreeNode {
93+
if prel > prer {
94+
return nil
95+
}
96+
root := &TreeNode{Val: preorder[prel]}
97+
if prel == prer {
98+
return root
99+
}
100+
leftRootIndex := postMap[preorder[prel+1]]
101+
leftLength := leftRootIndex - postl + 1
102+
root.Left = dfs(prel+1, prel+leftLength, postl, leftRootIndex)
103+
root.Right = dfs(prel+leftLength+1, prer, leftRootIndex+1, postr-1)
104+
return root
105+
}
106+
return dfs(0, len(preorder)-1, 0, len(postorder)-1)
107+
}
108+
```
76109

110+
### **C++**
111+
112+
```cpp
113+
/**
114+
* Definition for a binary tree node.
115+
* struct TreeNode {
116+
* int val;
117+
* TreeNode *left;
118+
* TreeNode *right;
119+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
120+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
121+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
122+
* };
123+
*/
124+
class Solution {
125+
public:
126+
unordered_map<int, int> postMap;
127+
TreeNode* constructFromPrePost(vector<int>& preorder, vector<int>& postorder) {
128+
for (int i = 0; i < postorder.size(); i++) {
129+
postMap[postorder[i]] = i;
130+
}
131+
return build(preorder, 0, preorder.size() - 1, postorder, 0, postorder.size() - 1);
132+
}
133+
134+
TreeNode* build(vector<int>& preorder, int prel, int prer, vector<int>& postorder, int postl, int postr) {
135+
if (prel > prer) return nullptr;
136+
TreeNode* root = new TreeNode(preorder[prel]);
137+
if (prel == prer) return root;
138+
int leftRootIndex = postMap[preorder[prel + 1]];
139+
int leftLength = leftRootIndex - postl + 1;
140+
root->left = build(preorder, prel + 1, prel + leftLength, postorder, postl, leftRootIndex);
141+
root->right = build(preorder, prel + leftLength + 1, prer, postorder, leftRootIndex + 1, postr - 1);
142+
return root;
143+
}
144+
};
77145
```
78146

79147
### **...**

‎solution/0800-0899/0889.Construct Binary Tree from Preorder and Postorder Traversal/Solution.cpp

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10+
* };
11+
*/
12+
class Solution {
13+
public:
14+
unordered_map<int, int> postMap;
15+
TreeNode* constructFromPrePost(vector<int>& preorder, vector<int>& postorder) {
16+
for (int i = 0; i < postorder.size(); i++) {
17+
postMap[postorder[i]] = i;
18+
}
19+
return build(preorder, 0, preorder.size() - 1, postorder, 0, postorder.size() - 1);
20+
}
21+
22+
TreeNode* build(vector<int>& preorder, int prel, int prer, vector<int>& postorder, int postl, int postr) {
23+
if (prel > prer) return nullptr;
24+
TreeNode* root = new TreeNode(preorder[prel]);
25+
if (prel == prer) return root;
26+
int leftRootIndex = postMap[preorder[prel + 1]];
27+
int leftLength = leftRootIndex - postl + 1;
28+
root->left = build(preorder, prel + 1, prel + leftLength, postorder, postl, leftRootIndex);
29+
root->right = build(preorder, prel + leftLength + 1, prer, postorder, leftRootIndex + 1, postr - 1);
30+
return root;
31+
}
32+
};

‎solution/0800-0899/0889.Construct Binary Tree from Preorder and Postorder Traversal/Solution.go

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* type TreeNode struct {
4+
* Val int
5+
* Left *TreeNode
6+
* Right *TreeNode
7+
* }
8+
*/
9+
func constructFromPrePost(preorder []int, postorder []int) *TreeNode {
10+
postMap := make(map[int]int)
11+
for index, v := range postorder {
12+
postMap[v] = index
13+
}
14+
var dfs func(prel, prer, postl, postr int) *TreeNode
15+
dfs = func(prel, prer, postl, postr int) *TreeNode {
16+
if prel > prer {
17+
return nil
18+
}
19+
root := &TreeNode{Val: preorder[prel]}
20+
if prel == prer {
21+
return root
22+
}
23+
leftRootIndex := postMap[preorder[prel+1]]
24+
leftLength := leftRootIndex - postl + 1
25+
root.Left = dfs(prel+1, prel+leftLength, postl, leftRootIndex)
26+
root.Right = dfs(prel+leftLength+1, prer, leftRootIndex+1, postr-1)
27+
return root
28+
}
29+
return dfs(0, len(preorder)-1, 0, len(postorder)-1)
30+
}

0 commit comments

Comments
 (0)