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 14311e4

Browse files
fix: update solutions to lc problems: No.105,106 (doocs#2359)
1 parent 58a4c04 commit 14311e4

File tree

7 files changed

+42
-53
lines changed

7 files changed

+42
-53
lines changed

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

Lines changed: 21 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -99,13 +99,11 @@ class Solution:
9999
*/
100100
class Solution {
101101
private int[] preorder;
102-
private int[] inorder;
103102
private Map<Integer, Integer> d = new HashMap<>();
104103

105104
public TreeNode buildTree(int[] preorder, int[] inorder) {
106105
int n = preorder.length;
107106
this.preorder = preorder;
108-
this.inorder = inorder;
109107
for (int i = 0; i < n; ++i) {
110108
d.put(inorder[i], i);
111109
}
@@ -337,43 +335,36 @@ class Solution:
337335
```
338336

339337
```java
340-
/**
341-
* Definition for a binary tree node.
342-
* public class TreeNode {
343-
* int val;
344-
* TreeNode left;
345-
* TreeNode right;
346-
* TreeNode() {}
347-
* TreeNode(int val) { this.val = val; }
348-
* TreeNode(int val, TreeNode left, TreeNode right) {
349-
* this.val = val;
350-
* this.left = left;
351-
* this.right = right;
352-
* }
353-
* }
354-
*/
355338
class Solution {
356-
private int[] preorder;
357-
private Map<Integer, Integer> d = new HashMap<>();
339+
private List<Integer> preorder;
340+
private Map<Integer, List<Integer>> d = new HashMap<>();
358341

359-
public TreeNodebuildTree(int[] preorder, int[] inorder) {
360-
int n = preorder.length;
361-
this.preorder = preorder;
342+
public List<TreeNode>getBinaryTrees(List<Integer>preOrder, List<Integer>inOrder) {
343+
int n = preOrder.size();
344+
this.preorder = preOrder;
362345
for (int i = 0; i < n; ++i) {
363-
d.put(inorder[i], i);
346+
d.computeIfAbsent(inOrder.get(i), k ->newArrayList<>()).add(i);
364347
}
365348
return dfs(0, 0, n);
366349
}
367350

368-
private TreeNode dfs(int i, int j, int n) {
351+
private List<TreeNode> dfs(int i, int j, int n) {
352+
List<TreeNode> ans = new ArrayList<>();
369353
if (n <= 0) {
370-
return null;
354+
ans.add(null);
355+
return ans;
371356
}
372-
int v = preorder[i];
373-
int k = d.get(v);
374-
TreeNode l = dfs(i + 1, j, k - j);
375-
TreeNode r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j));
376-
return new TreeNode(v, l, r);
357+
int v = preorder.get(i);
358+
for (int k : d.get(v)) {
359+
if (k >= j && k < j + n) {
360+
for (TreeNode l : dfs(i + 1, j, k - j)) {
361+
for (TreeNode r : dfs(i + 1 + k - j, k + 1, n - 1 - (k - j))) {
362+
ans.add(new TreeNode(v, l, r));
363+
}
364+
}
365+
}
366+
}
367+
return ans;
377368
}
378369
}
379370
```

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

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -95,13 +95,11 @@ class Solution:
9595
*/
9696
class Solution {
9797
private int[] preorder;
98-
private int[] inorder;
9998
private Map<Integer, Integer> d = new HashMap<>();
10099

101100
public TreeNode buildTree(int[] preorder, int[] inorder) {
102101
int n = preorder.length;
103102
this.preorder = preorder;
104-
this.inorder = inorder;
105103
for (int i = 0; i < n; ++i) {
106104
d.put(inorder[i], i);
107105
}

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

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -15,13 +15,11 @@
1515
*/
1616
class Solution {
1717
private int[] preorder;
18-
private int[] inorder;
1918
private Map<Integer, Integer> d = new HashMap<>();
2019

2120
public TreeNode buildTree(int[] preorder, int[] inorder) {
2221
int n = preorder.length;
2322
this.preorder = preorder;
24-
this.inorder = inorder;
2523
for (int i = 0; i < n; ++i) {
2624
d.put(inorder[i], i);
2725
}

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

Lines changed: 21 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -14,26 +14,34 @@
1414
* }
1515
*/
1616
class Solution {
17-
private int[] preorder;
18-
private Map<Integer, Integer> d = new HashMap<>();
17+
private List<Integer> preorder;
18+
private Map<Integer, List<Integer>> d = new HashMap<>();
1919

20-
public TreeNodebuildTree(int[] preorder, int[] inorder) {
21-
int n = preorder.length;
22-
this.preorder = preorder;
20+
public List<TreeNode> getBinaryTrees(List<Integer> preOrder, List<Integer> inOrder) {
21+
int n = preOrder.size();
22+
this.preorder = preOrder;
2323
for (int i = 0; i < n; ++i) {
24-
d.put(inorder[i], i);
24+
d.computeIfAbsent(inOrder.get(i), k -> newArrayList<>()).add(i);
2525
}
2626
return dfs(0, 0, n);
2727
}
2828

29-
private TreeNode dfs(int i, int j, int n) {
29+
private List<TreeNode> dfs(int i, int j, int n) {
30+
List<TreeNode> ans = new ArrayList<>();
3031
if (n <= 0) {
31-
return null;
32+
ans.add(null);
33+
return ans;
3234
}
33-
int v = preorder[i];
34-
int k = d.get(v);
35-
TreeNode l = dfs(i + 1, j, k - j);
36-
TreeNode r = dfs(i + 1 + k - j, k + 1, n - 1 - (k - j));
37-
return new TreeNode(v, l, r);
35+
int v = preorder.get(i);
36+
for (int k : d.get(v)) {
37+
if (k >= j && k < j + n) {
38+
for (TreeNode l : dfs(i + 1, j, k - j)) {
39+
for (TreeNode r : dfs(i + 1 + k - j, k + 1, n - 1 - (k - j))) {
40+
ans.add(new TreeNode(v, l, r));
41+
}
42+
}
43+
}
44+
}
45+
return ans;
3846
}
3947
}

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

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -94,11 +94,9 @@ class Solution:
9494
*/
9595
class Solution {
9696
private Map<Integer, Integer> d = new HashMap<>();
97-
private int[] inorder;
9897
private int[] postorder;
9998

10099
public TreeNode buildTree(int[] inorder, int[] postorder) {
101-
this.inorder = inorder;
102100
this.postorder = postorder;
103101
int n = inorder.length;
104102
for (int i = 0; i < n; ++i) {

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

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -90,11 +90,9 @@ class Solution:
9090
*/
9191
class Solution {
9292
private Map<Integer, Integer> d = new HashMap<>();
93-
private int[] inorder;
9493
private int[] postorder;
9594

9695
public TreeNode buildTree(int[] inorder, int[] postorder) {
97-
this.inorder = inorder;
9896
this.postorder = postorder;
9997
int n = inorder.length;
10098
for (int i = 0; i < n; ++i) {

‎solution/0100-0199/0106.Construct Binary Tree from Inorder and Postorder Traversal/Solution.java‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -15,11 +15,9 @@
1515
*/
1616
class Solution {
1717
private Map<Integer, Integer> d = new HashMap<>();
18-
private int[] inorder;
1918
private int[] postorder;
2019

2120
public TreeNode buildTree(int[] inorder, int[] postorder) {
22-
this.inorder = inorder;
2321
this.postorder = postorder;
2422
int n = inorder.length;
2523
for (int i = 0; i < n; ++i) {

0 commit comments

Comments
(0)

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