Skip to content

Commit 1f02e4a

Browse files
yanglbmeyanglbme
authoredAug 9, 2023
feat: add solutions to lc problem: No.0105 (doocs#1423)
No.0105.Construct Binary Tree from Preorder and Inorder Traversal
1 parent 566245f commit 1f02e4a

File tree

12 files changed

+632
-345
lines changed

12 files changed

+632
-345
lines changed
 

‎solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README.md

+226-90
Large diffs are not rendered by default.

‎solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README_EN.md

+223-89
Original file line numberDiff line numberDiff line change
@@ -49,39 +49,40 @@
4949
# self.right = right
5050
class Solution:
5151
def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
52-
if not preorder:
53-
return None
54-
v = preorder[0]
55-
root = TreeNode(val=v)
56-
i = inorder.index(v)
57-
root.left = self.buildTree(preorder[1 : 1 + i], inorder[:i])
58-
root.right = self.buildTree(preorder[1 + i :], inorder[i + 1 :])
59-
return root
60-
```
61-
62-
```python
63-
# Definition for a binary tree node.
64-
# class TreeNode:
65-
# def __init__(self, val=0, left=None, right=None):
66-
# self.val = val
67-
# self.left = left
68-
# self.right = right
69-
class Solution:
70-
def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
71-
def dfs(i, j, n):
52+
def dfs(i: int, j: int, n: int):
7253
if n <= 0:
7354
return None
7455
v = preorder[i]
7556
k = d[v]
76-
root = TreeNode(v)
77-
root.left = dfs(i + 1, j, k - j)
78-
root.right = dfs(i + 1 + k - j, k + 1, n - k + j - 1)
79-
return root
57+
l = dfs(i + 1, j, k - j)
58+
r = dfs(i + 1 + k - j, k + 1, n - k + j - 1)
59+
return TreeNode(v, l, r)
8060

8161
d = {v: i for i, v in enumerate(inorder)}
8262
return dfs(0, 0, len(preorder))
8363
```
8464

65+
```python
66+
class Solution:
67+
def getBinaryTrees(self, preOrder: List[int], inOrder: List[int]) -> List[TreeNode]:
68+
def dfs(i: int, j: int, n: int) -> List[TreeNode]:
69+
if n <= 0:
70+
return [None]
71+
v = preOrder[i]
72+
ans = []
73+
for k in d[v]:
74+
if j <= k < j + n:
75+
for l in dfs(i + 1, j, k - j):
76+
for r in dfs(i + 1 + k - j, k + 1, n - 1 - (k - j)):
77+
ans.append(TreeNode(v, l, r))
78+
return ans
79+
80+
d = defaultdict(list)
81+
for i, x in enumerate(inOrder):
82+
d[x].append(i)
83+
return dfs(0, 0, len(preOrder))
84+
```
85+
8586
### **Java**
8687

8788
```java
@@ -101,25 +102,71 @@ class Solution:
101102
* }
102103
*/
103104
class Solution {
104-
private Map<Integer, Integer> indexes = new HashMap<>();
105+
private int[] preorder;
106+
private int[] inorder;
107+
private Map<Integer, Integer> d = new HashMap<>();
108+
109+
public TreeNode buildTree(int[] preorder, int[] inorder) {
110+
int n = preorder.length;
111+
this.preorder = preorder;
112+
this.inorder = inorder;
113+
for (int i = 0; i < n; ++i) {
114+
d.put(inorder[i], i);
115+
}
116+
return dfs(0, 0, n);
117+
}
118+
119+
private TreeNode dfs(int i, int j, int n) {
120+
if (n <= 0) {
121+
return null;
122+
}
123+
int v = preorder[i];
124+
int k = d.get(v);
125+
TreeNode l = dfs(i + 1, j, k - j);
126+
TreeNode r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j));
127+
return new TreeNode(v, l, r);
128+
}
129+
}
130+
```
131+
132+
```java
133+
/**
134+
* Definition for a binary tree node.
135+
* public class TreeNode {
136+
* int val;
137+
* TreeNode left;
138+
* TreeNode right;
139+
* TreeNode() {}
140+
* TreeNode(int val) { this.val = val; }
141+
* TreeNode(int val, TreeNode left, TreeNode right) {
142+
* this.val = val;
143+
* this.left = left;
144+
* this.right = right;
145+
* }
146+
* }
147+
*/
148+
class Solution {
149+
private int[] preorder;
150+
private Map<Integer, Integer> d = new HashMap<>();
105151

106152
public TreeNode buildTree(int[] preorder, int[] inorder) {
107-
for (int i = 0; i < inorder.length; ++i) {
108-
indexes.put(inorder[i], i);
153+
int n = preorder.length;
154+
this.preorder = preorder;
155+
for (int i = 0; i < n; ++i) {
156+
d.put(inorder[i], i);
109157
}
110-
return dfs(preorder, inorder, 0, 0, preorder.length);
158+
return dfs(0, 0, n);
111159
}
112160

113-
private TreeNode dfs(int[] preorder, int[] inorder, int i, int j, int n) {
161+
private TreeNode dfs(int i, int j, int n) {
114162
if (n <= 0) {
115163
return null;
116164
}
117165
int v = preorder[i];
118-
int k = indexes.get(v);
119-
TreeNode root = new TreeNode(v);
120-
root.left = dfs(preorder, inorder, i + 1, j, k - j);
121-
root.right = dfs(preorder, inorder, i + 1 + k - j, k + 1, n - k + j - 1);
122-
return root;
166+
int k = d.get(v);
167+
TreeNode l = dfs(i + 1, j, k - j);
168+
TreeNode r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j));
169+
return new TreeNode(v, l, r);
123170
}
124171
}
125172
```
@@ -140,21 +187,68 @@ class Solution {
140187
*/
141188
class Solution {
142189
public:
143-
unordered_map<int, int> indexes;
144-
145190
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
146-
for (int i = 0; i < inorder.size(); ++i) indexes[inorder[i]] = i;
147-
return dfs(preorder, inorder, 0, 0, inorder.size());
191+
int n = preorder.size();
192+
unordered_map<int, int> d;
193+
for (int i = 0; i < n; ++i) {
194+
d[inorder[i]] = i;
195+
}
196+
function<TreeNode*(int, int, int)> dfs = [&](int i, int j, int n) -> TreeNode* {
197+
if (n <= 0) {
198+
return nullptr;
199+
}
200+
int v = preorder[i];
201+
int k = d[v];
202+
TreeNode* l = dfs(i + 1, j, k - j);
203+
TreeNode* r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j));
204+
return new TreeNode(v, l, r);
205+
};
206+
return dfs(0, 0, n);
148207
}
208+
};
209+
```
149210
150-
TreeNode* dfs(vector<int>& preorder, vector<int>& inorder, int i, int j, int n) {
151-
if (n <= 0) return nullptr;
152-
int v = preorder[i];
153-
int k = indexes[v];
154-
TreeNode* root = new TreeNode(v);
155-
root->left = dfs(preorder, inorder, i + 1, j, k - j);
156-
root->right = dfs(preorder, inorder, i + 1 + k - j, k + 1, n - k + j - 1);
157-
return root;
211+
```cpp
212+
/**
213+
* struct TreeNode {
214+
* int val;
215+
* struct TreeNode *left;
216+
* struct TreeNode *right;
217+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
218+
* };
219+
*/
220+
class Solution {
221+
public:
222+
vector<TreeNode*> getBinaryTrees(vector<int>& preOrder, vector<int>& inOrder) {
223+
int n = inOrder.size();
224+
unordered_map<int, vector<int>> d;
225+
for (int i = 0; i < n; ++i) {
226+
d[inOrder[i]].push_back(i);
227+
}
228+
function<vector<TreeNode*>(int, int, int)> dfs = [&](int i,int j, int n) -> vector<TreeNode*> {
229+
vector<TreeNode*> ans;
230+
if (n <= 0) {
231+
ans.push_back(nullptr);
232+
return ans;
233+
}
234+
int v = preOrder[i];
235+
for (int k : d[v]) {
236+
if (k >= j && k < j + n) {
237+
auto lefts = dfs(i + 1, j, k - j);
238+
auto rights = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j));
239+
for (TreeNode* l : lefts) {
240+
for (TreeNode* r : rights) {
241+
TreeNode* node = new TreeNode(v);
242+
node->left = l;
243+
node->right = r;
244+
ans.push_back(node);
245+
}
246+
}
247+
}
248+
}
249+
return ans;
250+
};
251+
return dfs(0, 0, n);
158252
}
159253
};
160254
```
@@ -171,23 +265,54 @@ public:
171265
* }
172266
*/
173267
func buildTree(preorder []int, inorder []int) *TreeNode {
174-
indexes := make(map[int]int)
175-
for i, v := range inorder {
176-
indexes[v] = i
268+
d := map[int]int{}
269+
for i, x := range inorder {
270+
d[x] = i
177271
}
178272
var dfs func(i, j, n int) *TreeNode
179273
dfs = func(i, j, n int) *TreeNode {
180274
if n <= 0 {
181275
return nil
182276
}
183277
v := preorder[i]
184-
k := indexes[v]
185-
root := &TreeNode{Val: v}
186-
root.Left = dfs(i+1, j, k-j)
187-
root.Right = dfs(i+1+k-j, k+1, n-k+j-1)
188-
return root
278+
k := d[v]
279+
l := dfs(i+1, j, k-j)
280+
r := dfs(i+1+k-j, k+1, n-1-(k-j))
281+
return &TreeNode{v, l, r}
189282
}
190-
return dfs(0, 0, len(inorder))
283+
return dfs(0, 0, len(preorder))
284+
}
285+
```
286+
287+
```go
288+
func getBinaryTrees(preOrder []int, inOrder []int) []*TreeNode {
289+
n := len(preOrder)
290+
d := map[int][]int{}
291+
for i, x := range inOrder {
292+
d[x] = append(d[x], i)
293+
}
294+
var dfs func(i, j, n int) []*TreeNode
295+
dfs = func(i, j, n int) []*TreeNode {
296+
ans := []*TreeNode{}
297+
if n <= 0 {
298+
ans = append(ans, nil)
299+
return ans
300+
}
301+
v := preOrder[i]
302+
for _, k := range d[v] {
303+
if k >= j && k < j+n {
304+
lefts := dfs(i+1, j, k-j)
305+
rights := dfs(i+1+k-j, k+1, n-1-(k-j))
306+
for _, left := range lefts {
307+
for _, right := range rights {
308+
ans = append(ans, &TreeNode{v, left, right})
309+
}
310+
}
311+
}
312+
}
313+
return ans
314+
}
315+
return dfs(0, 0, n)
191316
}
192317
```
193318

@@ -209,17 +334,22 @@ func buildTree(preorder []int, inorder []int) *TreeNode {
209334
*/
210335

211336
function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
212-
const n = preorder.length;
213-
if (n === 0) {
214-
return null;
337+
const d: Map<number, number> = new Map();
338+
const n = inorder.length;
339+
for (let i = 0; i < n; ++i) {
340+
d.set(inorder[i], i);
215341
}
216-
const val = preorder[0];
217-
const index = inorder.indexOf(val);
218-
return new TreeNode(
219-
val,
220-
buildTree(preorder.slice(1, index + 1), inorder.slice(0, index)),
221-
buildTree(preorder.slice(index + 1), inorder.slice(index + 1)),
222-
);
342+
const dfs = (i: number, j: number, n: number): TreeNode | null => {
343+
if (n <= 0) {
344+
return null;
345+
}
346+
const v = preorder[i];
347+
const k = d.get(v)!;
348+
const l = dfs(i + 1, j, k - j);
349+
const r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j));
350+
return new TreeNode(v, l, r);
351+
};
352+
return dfs(0, 0, n);
223353
}
224354
```
225355

@@ -246,22 +376,26 @@ function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
246376
// }
247377
use std::rc::Rc;
248378
use std::cell::RefCell;
379+
use std::collections::HashMap;
249380
impl Solution {
250-
fn to_tree(preorder: &[i32], inorder: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {
251-
if preorder.is_empty() {
252-
return None;
381+
pub fn build_tree(preorder: Vec<i32>, inorder: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
382+
let mut d = HashMap::new();
383+
for (i, &x) in inorder.iter().enumerate() {
384+
d.insert(x, i);
253385
}
254-
let val = preorder[0];
255-
let index = inorder.iter().position(|&v| v == val).unwrap();
256-
Some(Rc::new(RefCell::new(TreeNode {
257-
val,
258-
left: Self::to_tree(&preorder[1..index + 1], &inorder[..index]),
259-
right: Self::to_tree(&preorder[index + 1..], &inorder[index + 1..]),
260-
})))
386+
Self::dfs(&preorder, &d, 0, 0, preorder.len())
261387
}
262388

263-
pub fn build_tree(preorder: Vec<i32>, inorder: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
264-
Self::to_tree(&preorder[..], &inorder[..])
389+
pub fn dfs(preorder: &Vec<i32>, d: &HashMap<i32, usize>, i: usize, j: usize, n: usize) -> Option<Rc<RefCell<TreeNode>>> {
390+
if n <= 0 {
391+
return None;
392+
}
393+
let v = preorder[i];
394+
let k = d[&v];
395+
let mut root = TreeNode::new(v);
396+
root.left = Self::dfs(preorder, d, i + 1, j, k - j);
397+
root.right = Self::dfs(preorder, d, i + k - j + 1, k + 1, n - k + j - 1);
398+
Some(Rc::new(RefCell::new(root)))
265399
}
266400
}
267401
```
@@ -283,22 +417,22 @@ impl Solution {
283417
* @return {TreeNode}
284418
*/
285419
var buildTree = function (preorder, inorder) {
286-
function dfs(i, j, n) {
420+
const d = new Map();
421+
const n = inorder.length;
422+
for (let i = 0; i < n; ++i) {
423+
d.set(inorder[i], i);
424+
}
425+
const dfs = (i, j, n) => {
287426
if (n <= 0) {
288427
return null;
289428
}
290429
const v = preorder[i];
291-
const k = d[v];
292-
const root = new TreeNode(v);
293-
root.left = dfs(i + 1, j, k - j);
294-
root.right = dfs(i + 1 + k - j, k + 1, n - k + j - 1);
295-
return root;
296-
}
297-
const d = new Map();
298-
for (const [i, v] of inorder.entries()) {
299-
d[v] = i;
300-
}
301-
return dfs(0, 0, inorder.length);
430+
const k = d.get(v);
431+
const l = dfs(i + 1, j, k - j);
432+
const r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j));
433+
return new TreeNode(v, l, r);
434+
};
435+
return dfs(0, 0, n);
302436
};
303437
```
304438

0 commit comments

Comments
 (0)
Please sign in to comment.