Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit ab085b9

Browse files
authored
feat: add solutions to lc problem: No.0889 (#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
### **...**
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+
};
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)

AltStyle によって変換されたページ (->オリジナル) /