Skip to content

Commit df6cc4a

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problems: No.0108,0109
1 parent f063133 commit df6cc4a

File tree

12 files changed

+732
-61
lines changed

12 files changed

+732
-61
lines changed

‎solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/README.md

+110-1
Original file line numberDiff line numberDiff line change
@@ -51,15 +51,124 @@
5151
<!-- 这里可写当前语言的特殊实现逻辑 -->
5252

5353
```python
54-
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 sortedArrayToBST(self, nums: List[int]) -> TreeNode:
62+
def buildBST(nums, start, end):
63+
if start > end:
64+
return None
65+
mid = (start + end) >> 1
66+
return TreeNode(nums[mid], buildBST(nums, start, mid - 1), buildBST(nums, mid + 1, end))
67+
68+
return buildBST(nums, 0, len(nums) - 1)
5569
```
5670

5771
### **Java**
5872

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

6175
```java
76+
/**
77+
* Definition for a binary tree node.
78+
* public class TreeNode {
79+
* int val;
80+
* TreeNode left;
81+
* TreeNode right;
82+
* TreeNode() {}
83+
* TreeNode(int val) { this.val = val; }
84+
* TreeNode(int val, TreeNode left, TreeNode right) {
85+
* this.val = val;
86+
* this.left = left;
87+
* this.right = right;
88+
* }
89+
* }
90+
*/
91+
class Solution {
92+
public TreeNode sortedArrayToBST(int[] nums) {
93+
return buildBST(nums, 0, nums.length - 1);
94+
}
95+
96+
private TreeNode buildBST(int[] nums, int start, int end) {
97+
if (start > end) {
98+
return null;
99+
}
100+
int mid = (start + end) >> 1;
101+
TreeNode root = new TreeNode(nums[mid]);
102+
root.left = buildBST(nums, start, mid - 1);
103+
root.right = buildBST(nums, mid + 1, end);
104+
return root;
105+
}
106+
}
107+
```
108+
109+
### **C++**
110+
111+
```cpp
112+
/**
113+
* Definition for a binary tree node.
114+
* struct TreeNode {
115+
* int val;
116+
* TreeNode *left;
117+
* TreeNode *right;
118+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
119+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
120+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
121+
* };
122+
*/
123+
class Solution {
124+
public:
125+
TreeNode* sortedArrayToBST(vector<int>& nums) {
126+
return buildBST(nums, 0, nums.size() - 1);
127+
}
128+
129+
private:
130+
TreeNode* buildBST(vector<int>& nums, int start, int end) {
131+
if (start > end) {
132+
return nullptr;
133+
}
134+
int mid = (start + end) / 2;
135+
TreeNode *root = new TreeNode(nums[mid]);
136+
root->left = buildBST(nums, start, mid - 1);
137+
root->right = buildBST(nums, mid + 1, end);
138+
return root;
139+
}
140+
};
141+
```
62142
143+
### **JavaScript**
144+
145+
```js
146+
/**
147+
* Definition for a binary tree node.
148+
* function TreeNode(val, left, right) {
149+
* this.val = (val===undefined ? 0 : val)
150+
* this.left = (left===undefined ? null : left)
151+
* this.right = (right===undefined ? null : right)
152+
* }
153+
*/
154+
/**
155+
* @param {number[]} nums
156+
* @return {TreeNode}
157+
*/
158+
var sortedArrayToBST = function(nums) {
159+
const buildBST = (nums, start, end) => {
160+
if (start > end) {
161+
return null;
162+
}
163+
const mid = (start + end) >> 1;
164+
const root = new TreeNode(nums[mid]);
165+
root.left = buildBST(nums, start, mid - 1);
166+
root.right = buildBST(nums, mid + 1, end);
167+
return root;
168+
}
169+
170+
return buildBST(nums, 0, nums.length - 1);
171+
};
63172
```
64173

65174
### **...**

‎solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/README_EN.md

+110-1
Original file line numberDiff line numberDiff line change
@@ -43,13 +43,122 @@
4343
### **Python3**
4444

4545
```python
46-
46+
# Definition for a binary tree node.
47+
# class TreeNode:
48+
# def __init__(self, val=0, left=None, right=None):
49+
# self.val = val
50+
# self.left = left
51+
# self.right = right
52+
class Solution:
53+
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
54+
def buildBST(nums, start, end):
55+
if start > end:
56+
return None
57+
mid = (start + end) >> 1
58+
return TreeNode(nums[mid], buildBST(nums, start, mid - 1), buildBST(nums, mid + 1, end))
59+
60+
return buildBST(nums, 0, len(nums) - 1)
4761
```
4862

4963
### **Java**
5064

5165
```java
66+
/**
67+
* Definition for a binary tree node.
68+
* public class TreeNode {
69+
* int val;
70+
* TreeNode left;
71+
* TreeNode right;
72+
* TreeNode() {}
73+
* TreeNode(int val) { this.val = val; }
74+
* TreeNode(int val, TreeNode left, TreeNode right) {
75+
* this.val = val;
76+
* this.left = left;
77+
* this.right = right;
78+
* }
79+
* }
80+
*/
81+
class Solution {
82+
public TreeNode sortedArrayToBST(int[] nums) {
83+
return buildBST(nums, 0, nums.length - 1);
84+
}
85+
86+
private TreeNode buildBST(int[] nums, int start, int end) {
87+
if (start > end) {
88+
return null;
89+
}
90+
int mid = (start + end) >> 1;
91+
TreeNode root = new TreeNode(nums[mid]);
92+
root.left = buildBST(nums, start, mid - 1);
93+
root.right = buildBST(nums, mid + 1, end);
94+
return root;
95+
}
96+
}
97+
```
98+
99+
### **C++**
100+
101+
```cpp
102+
/**
103+
* Definition for a binary tree node.
104+
* struct TreeNode {
105+
* int val;
106+
* TreeNode *left;
107+
* TreeNode *right;
108+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
109+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
110+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
111+
* };
112+
*/
113+
class Solution {
114+
public:
115+
TreeNode* sortedArrayToBST(vector<int>& nums) {
116+
return buildBST(nums, 0, nums.size() - 1);
117+
}
118+
119+
private:
120+
TreeNode* buildBST(vector<int>& nums, int start, int end) {
121+
if (start > end) {
122+
return nullptr;
123+
}
124+
int mid = (start + end) / 2;
125+
TreeNode *root = new TreeNode(nums[mid]);
126+
root->left = buildBST(nums, start, mid - 1);
127+
root->right = buildBST(nums, mid + 1, end);
128+
return root;
129+
}
130+
};
131+
```
52132
133+
### **JavaScript**
134+
135+
```js
136+
/**
137+
* Definition for a binary tree node.
138+
* function TreeNode(val, left, right) {
139+
* this.val = (val===undefined ? 0 : val)
140+
* this.left = (left===undefined ? null : left)
141+
* this.right = (right===undefined ? null : right)
142+
* }
143+
*/
144+
/**
145+
* @param {number[]} nums
146+
* @return {TreeNode}
147+
*/
148+
var sortedArrayToBST = function(nums) {
149+
const buildBST = (nums, start, end) => {
150+
if (start > end) {
151+
return null;
152+
}
153+
const mid = (start + end) >> 1;
154+
const root = new TreeNode(nums[mid]);
155+
root.left = buildBST(nums, start, mid - 1);
156+
root.right = buildBST(nums, mid + 1, end);
157+
return root;
158+
}
159+
160+
return buildBST(nums, 0, nums.length - 1);
161+
};
53162
```
54163

55164
### **...**

‎solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.cpp

+13-9
Original file line numberDiff line numberDiff line change
@@ -4,22 +4,26 @@
44
* int val;
55
* TreeNode *left;
66
* TreeNode *right;
7-
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
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) {}
810
* };
911
*/
1012
class Solution {
1113
public:
1214
TreeNode* sortedArrayToBST(vector<int>& nums) {
13-
return helper(nums, 0, nums.size() - 1);
15+
return buildBST(nums, 0, nums.size() - 1);
1416
}
1517

1618
private:
17-
TreeNode* helper(vector<int> &nums, int left, int right) {
18-
if (left > right) return nullptr;
19-
int mid = left + (right - left) / 2;
20-
TreeNode *cur = new TreeNode(nums[mid]);
21-
cur->left = helper(nums, left, mid - 1);
22-
cur->right = helper(nums, mid + 1, right);
23-
return cur;
19+
TreeNode* buildBST(vector<int>& nums, int start, int end) {
20+
if (start > end) {
21+
return nullptr;
22+
}
23+
int mid = (start + end) / 2;
24+
TreeNode *root = new TreeNode(nums[mid]);
25+
root->left = buildBST(nums, start, mid - 1);
26+
root->right = buildBST(nums, mid + 1, end);
27+
return root;
2428
}
2529
};

‎solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.java

+14-8
Original file line numberDiff line numberDiff line change
@@ -4,22 +4,28 @@
44
* int val;
55
* TreeNode left;
66
* TreeNode right;
7-
* TreeNode(int x) { val = x; }
7+
* TreeNode() {}
8+
* TreeNode(int val) { this.val = val; }
9+
* TreeNode(int val, TreeNode left, TreeNode right) {
10+
* this.val = val;
11+
* this.left = left;
12+
* this.right = right;
13+
* }
814
* }
915
*/
1016
class Solution {
1117
public TreeNode sortedArrayToBST(int[] nums) {
12-
return sortedArrayToBST(nums, 0, nums.length - 1);
18+
return buildBST(nums, 0, nums.length - 1);
1319
}
14-
15-
private TreeNode sortedArrayToBST(int[] nums, int l, int r) {
16-
if (l > r) {
20+
21+
private TreeNode buildBST(int[] nums, int start, int end) {
22+
if (start > end) {
1723
return null;
1824
}
19-
int mid = (l + r) >> 1;
25+
int mid = (start + end) >> 1;
2026
TreeNode root = new TreeNode(nums[mid]);
21-
root.left = sortedArrayToBST(nums, l, mid - 1);
22-
root.right = sortedArrayToBST(nums, mid + 1, r);
27+
root.left = buildBST(nums, start, mid - 1);
28+
root.right = buildBST(nums, mid + 1, end);
2329
return root;
2430
}
2531
}

‎solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.js

+17-14
Original file line numberDiff line numberDiff line change
@@ -1,23 +1,26 @@
11
/**
22
* Definition for a binary tree node.
3-
* function TreeNode(val) {
4-
* this.val = val;
5-
* this.left = this.right = null;
3+
* function TreeNode(val, left, right) {
4+
* this.val = (val===undefined ? 0 : val)
5+
* this.left = (left===undefined ? null : left)
6+
* this.right = (right===undefined ? null : right)
67
* }
78
*/
89
/**
910
* @param {number[]} nums
1011
* @return {TreeNode}
1112
*/
12-
var sortedArrayToBST = function (nums) {
13-
return nums ? buildTree(nums, 0, nums.length - 1) : null;
14-
};
13+
var sortedArrayToBST = function(nums) {
14+
const buildBST = (nums, start, end) => {
15+
if (start > end) {
16+
return null;
17+
}
18+
const mid = (start + end) >> 1;
19+
const root = new TreeNode(nums[mid]);
20+
root.left = buildBST(nums, start, mid - 1);
21+
root.right = buildBST(nums, mid + 1, end);
22+
return root;
23+
}
1524

16-
const buildTree = function (nums, left, right) {
17-
if (left > right) return null;
18-
let mid = Math.floor((left + right) / 2);
19-
let root = new TreeNode(nums[mid]);
20-
root.left = buildTree(nums, left, mid - 1);
21-
root.right = buildTree(nums, mid + 1, right);
22-
return root;
23-
};
25+
return buildBST(nums, 0, nums.length - 1);
26+
};

‎solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.py

+15
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
# Definition for a binary tree node.
2+
# class TreeNode:
3+
# def __init__(self, val=0, left=None, right=None):
4+
# self.val = val
5+
# self.left = left
6+
# self.right = right
7+
class Solution:
8+
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
9+
def buildBST(nums, start, end):
10+
if start > end:
11+
return None
12+
mid = (start + end) >> 1
13+
return TreeNode(nums[mid], buildBST(nums, start, mid - 1), buildBST(nums, mid + 1, end))
14+
15+
return buildBST(nums, 0, len(nums) - 1)

0 commit comments

Comments
 (0)