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 8bf8ea2

Browse files
committed
feat: add solutions to lc problems: No.0095
No.0095.Unique Binary Search Trees II
1 parent 9ae273a commit 8bf8ea2

File tree

7 files changed

+397
-76
lines changed

7 files changed

+397
-76
lines changed

‎solution/0000-0099/0095.Unique Binary Search Trees II/README.md‎

Lines changed: 145 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -51,15 +51,75 @@
5151
<!-- 这里可写当前语言的特殊实现逻辑 -->
5252

5353
```python
54+
# Definition for a binary tree node.
55+
# class TreeNode:
56+
# def __init__(self, val=0, left=None, right=None):
57+
# self.val = val
58+
# self.left = left
59+
# self.right = right
60+
class Solution:
61+
def generateTrees(self, n: int) -> List[TreeNode]:
62+
def gen(left, right):
63+
ans = []
64+
if left > right:
65+
ans.append(None)
66+
else:
67+
for i in range(left, right + 1):
68+
left_trees = gen(left, i - 1)
69+
right_trees = gen(i + 1, right)
70+
for l in left_trees:
71+
for r in right_trees:
72+
node = TreeNode(i, l, r)
73+
ans.append(node)
74+
return ans
5475

76+
return gen(1, n)
5577
```
5678

5779
### **Java**
5880

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

6183
```java
84+
/**
85+
* Definition for a binary tree node.
86+
* public class TreeNode {
87+
* int val;
88+
* TreeNode left;
89+
* TreeNode right;
90+
* TreeNode() {}
91+
* TreeNode(int val) { this.val = val; }
92+
* TreeNode(int val, TreeNode left, TreeNode right) {
93+
* this.val = val;
94+
* this.left = left;
95+
* this.right = right;
96+
* }
97+
* }
98+
*/
99+
class Solution {
100+
public List<TreeNode> generateTrees(int n) {
101+
return generateTrees(1, n);
102+
}
62103

104+
private List<TreeNode> generateTrees(int left, int right) {
105+
List<TreeNode> ans = new ArrayList<>();
106+
if (left > right) {
107+
ans.add(null);
108+
} else {
109+
for (int i = left; i <= right; ++i) {
110+
List<TreeNode> leftTrees = generateTrees(left, i - 1);
111+
List<TreeNode> rightTrees = generateTrees(i + 1, right);
112+
for (TreeNode l : leftTrees) {
113+
for (TreeNode r : rightTrees) {
114+
TreeNode node = new TreeNode(i, l, r);
115+
ans.add(node);
116+
}
117+
}
118+
}
119+
}
120+
return ans;
121+
}
122+
}
63123
```
64124

65125
### **TypeScript**
@@ -79,7 +139,7 @@
79139
* }
80140
*/
81141

82-
function generateTrees(n: number): Array<TreeNode | null> {
142+
function generateTrees(n: number): Array<TreeNode | null> {
83143
if (n == 0) return [];
84144
return helper(1, n);
85145
};
@@ -95,9 +155,7 @@ function helper (start: number, end: number): Array<TreeNode | null> {
95155
let rights = helper(i + 1, end);
96156
for (let left of lefts) {
97157
for (let right of rights) {
98-
let root = new TreeNode(i);
99-
root.left = left;
100-
root.right = right;
158+
let root = new TreeNode(i, left, right);
101159
ans.push(root);
102160
}
103161
}
@@ -106,6 +164,89 @@ function helper (start: number, end: number): Array<TreeNode | null> {
106164
}
107165
```
108166

167+
### **C++**
168+
169+
```cpp
170+
/**
171+
* Definition for a binary tree node.
172+
* struct TreeNode {
173+
* int val;
174+
* TreeNode *left;
175+
* TreeNode *right;
176+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
177+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
178+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
179+
* };
180+
*/
181+
class Solution {
182+
public:
183+
vector<TreeNode*> generateTrees(int n) {
184+
return gen(1, n);
185+
}
186+
187+
vector<TreeNode*> gen(int left, int right) {
188+
vector<TreeNode*> ans;
189+
if (left > right)
190+
{
191+
ans.push_back(nullptr);
192+
}
193+
else
194+
{
195+
for (int i = left; i <= right; ++i)
196+
{
197+
auto leftTrees = gen(left, i - 1);
198+
auto rightTrees = gen(i + 1, right);
199+
for (auto& l : leftTrees)
200+
{
201+
for (auto& r : rightTrees)
202+
{
203+
TreeNode* node = new TreeNode(i, l, r);
204+
ans.push_back(node);
205+
}
206+
}
207+
}
208+
}
209+
return ans;
210+
}
211+
};
212+
```
213+
214+
### **Go**
215+
216+
```go
217+
/**
218+
* Definition for a binary tree node.
219+
* type TreeNode struct {
220+
* Val int
221+
* Left *TreeNode
222+
* Right *TreeNode
223+
* }
224+
*/
225+
func generateTrees(n int) []*TreeNode {
226+
var gen func(left, right int) []*TreeNode
227+
gen = func(left, right int) []*TreeNode {
228+
var ans []*TreeNode
229+
if left > right {
230+
ans = append(ans, nil)
231+
} else {
232+
for i := left; i <= right; i++ {
233+
leftTrees := gen(left, i-1)
234+
rightTrees := gen(i+1, right)
235+
for _, l := range leftTrees {
236+
for _, r := range rightTrees {
237+
node := &TreeNode{i, l, r}
238+
ans = append(ans, node)
239+
}
240+
}
241+
}
242+
}
243+
return ans
244+
}
245+
246+
return gen(1, n)
247+
}
248+
```
249+
109250
### **...**
110251

111252
```

‎solution/0000-0099/0095.Unique Binary Search Trees II/README_EN.md‎

Lines changed: 146 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -36,13 +36,73 @@
3636
### **Python3**
3737

3838
```python
39-
39+
# Definition for a binary tree node.
40+
# class TreeNode:
41+
# def __init__(self, val=0, left=None, right=None):
42+
# self.val = val
43+
# self.left = left
44+
# self.right = right
45+
class Solution:
46+
def generateTrees(self, n: int) -> List[TreeNode]:
47+
def gen(left, right):
48+
ans = []
49+
if left > right:
50+
ans.append(None)
51+
else:
52+
for i in range(left, right + 1):
53+
left_trees = gen(left, i - 1)
54+
right_trees = gen(i + 1, right)
55+
for l in left_trees:
56+
for r in right_trees:
57+
node = TreeNode(i, l, r)
58+
ans.append(node)
59+
return ans
60+
61+
return gen(1, n)
4062
```
4163

4264
### **Java**
4365

4466
```java
67+
/**
68+
* Definition for a binary tree node.
69+
* public class TreeNode {
70+
* int val;
71+
* TreeNode left;
72+
* TreeNode right;
73+
* TreeNode() {}
74+
* TreeNode(int val) { this.val = val; }
75+
* TreeNode(int val, TreeNode left, TreeNode right) {
76+
* this.val = val;
77+
* this.left = left;
78+
* this.right = right;
79+
* }
80+
* }
81+
*/
82+
class Solution {
83+
public List<TreeNode> generateTrees(int n) {
84+
return generateTrees(1, n);
85+
}
4586

87+
private List<TreeNode> generateTrees(int left, int right) {
88+
List<TreeNode> ans = new ArrayList<>();
89+
if (left > right) {
90+
ans.add(null);
91+
} else {
92+
for (int i = left; i <= right; ++i) {
93+
List<TreeNode> leftTrees = generateTrees(left, i - 1);
94+
List<TreeNode> rightTrees = generateTrees(i + 1, right);
95+
for (TreeNode l : leftTrees) {
96+
for (TreeNode r : rightTrees) {
97+
TreeNode node = new TreeNode(i, l, r);
98+
ans.add(node);
99+
}
100+
}
101+
}
102+
}
103+
return ans;
104+
}
105+
}
46106
```
47107

48108
### **TypeScript**
@@ -62,7 +122,7 @@
62122
* }
63123
*/
64124

65-
function generateTrees(n: number): Array<TreeNode | null> {
125+
function generateTrees(n: number): Array<TreeNode | null> {
66126
if (n == 0) return [];
67127
return helper(1, n);
68128
};
@@ -78,9 +138,7 @@ function helper (start: number, end: number): Array<TreeNode | null> {
78138
let rights = helper(i + 1, end);
79139
for (let left of lefts) {
80140
for (let right of rights) {
81-
let root = new TreeNode(i);
82-
root.left = left;
83-
root.right = right;
141+
let root = new TreeNode(i, left, right);
84142
ans.push(root);
85143
}
86144
}
@@ -89,6 +147,89 @@ function helper (start: number, end: number): Array<TreeNode | null> {
89147
}
90148
```
91149

150+
### **C++**
151+
152+
```cpp
153+
/**
154+
* Definition for a binary tree node.
155+
* struct TreeNode {
156+
* int val;
157+
* TreeNode *left;
158+
* TreeNode *right;
159+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
160+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
161+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
162+
* };
163+
*/
164+
class Solution {
165+
public:
166+
vector<TreeNode*> generateTrees(int n) {
167+
return gen(1, n);
168+
}
169+
170+
vector<TreeNode*> gen(int left, int right) {
171+
vector<TreeNode*> ans;
172+
if (left > right)
173+
{
174+
ans.push_back(nullptr);
175+
}
176+
else
177+
{
178+
for (int i = left; i <= right; ++i)
179+
{
180+
auto leftTrees = gen(left, i - 1);
181+
auto rightTrees = gen(i + 1, right);
182+
for (auto& l : leftTrees)
183+
{
184+
for (auto& r : rightTrees)
185+
{
186+
TreeNode* node = new TreeNode(i, l, r);
187+
ans.push_back(node);
188+
}
189+
}
190+
}
191+
}
192+
return ans;
193+
}
194+
};
195+
```
196+
197+
### **Go**
198+
199+
```go
200+
/**
201+
* Definition for a binary tree node.
202+
* type TreeNode struct {
203+
* Val int
204+
* Left *TreeNode
205+
* Right *TreeNode
206+
* }
207+
*/
208+
func generateTrees(n int) []*TreeNode {
209+
var gen func(left, right int) []*TreeNode
210+
gen = func(left, right int) []*TreeNode {
211+
var ans []*TreeNode
212+
if left > right {
213+
ans = append(ans, nil)
214+
} else {
215+
for i := left; i <= right; i++ {
216+
leftTrees := gen(left, i-1)
217+
rightTrees := gen(i+1, right)
218+
for _, l := range leftTrees {
219+
for _, r := range rightTrees {
220+
node := &TreeNode{i, l, r}
221+
ans = append(ans, node)
222+
}
223+
}
224+
}
225+
}
226+
return ans
227+
}
228+
229+
return gen(1, n)
230+
}
231+
```
232+
92233
### **...**
93234

94235
```

0 commit comments

Comments
(0)

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