Skip to content

Commit ee6cae6

Browse files
thinkasanyyanglbme
thinkasany
and
yanglbme
authored
feat: add solutions to lc problem: No.0270 (#1557)
 No.0270.Closest Binary Search Tree Value --------- Co-authored-by: Yang Libin <contact@yanglibin.info>
1 parent 97a6863 commit ee6cae6

File tree

8 files changed

+428
-79
lines changed

8 files changed

+428
-79
lines changed

‎solution/0200-0299/0270.Closest Binary Search Tree Value/README.md

+217-36
Original file line numberDiff line numberDiff line change
@@ -38,14 +38,53 @@
3838

3939
<!-- 这里可写通用的实现逻辑 -->
4040

41-
二分查找。
41+
**方法一：中序遍历**
42+
43+
我们用一个变量 $mi$ 维护最小的差值，用一个变量 $ans$ 维护答案。初始时 $mi=\infty$, $ans=root.val$。
44+
45+
接下来，进行中序遍历，每次计算当前节点与目标值 $target$ 的差的绝对值 $t$。如果 $t \lt mi$，或者 $t = mi$ 且当前节点的值小于 $ans$，则更新 $mi$ 和 $ans$。
46+
47+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉搜索树的节点数。
48+
49+
**方法二：二分查找**
50+
51+
与方法一类似，我们用一个变量 $mi$ 维护最小的差值，用一个变量 $ans$ 维护答案。初始时 $mi=\infty$, $ans=root.val$。
52+
53+
接下来，进行二分查找，每次计算当前节点与目标值 $target$ 的差的绝对值 $t$。如果 $t \lt mi$，或者 $t = mi$ 且当前节点的值小于 $ans$，则更新 $mi$ 和 $ans$。如果当前节点的值大于 $target$，则查找左子树，否则查找右子树。当我们遍历到叶子节点时，就可以结束二分查找了。
54+
55+
时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 是二叉搜索树的节点数。
4256

4357
<!-- tabs:start -->
4458

4559
### **Python3**
4660

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

63+
```python
64+
# Definition for a binary tree node.
65+
# class TreeNode:
66+
# def __init__(self, val=0, left=None, right=None):
67+
# self.val = val
68+
# self.left = left
69+
# self.right = right
70+
class Solution:
71+
def closestValue(self, root: Optional[TreeNode], target: float) -> int:
72+
def dfs(root):
73+
if root is None:
74+
return
75+
dfs(root.left)
76+
nonlocal ans, mi
77+
t = abs(root.val - target)
78+
if t < mi:
79+
mi = t
80+
ans = root.val
81+
dfs(root.right)
82+
83+
ans, mi = root.val, inf
84+
dfs(root)
85+
return ans
86+
```
87+
4988
```python
5089
# Definition for a binary tree node.
5190
# class TreeNode:
@@ -58,7 +97,7 @@ class Solution:
5897
ans, mi = root.val, inf
5998
while root:
6099
t = abs(root.val - target)
61-
if t < mi:
100+
if t < mi or (t == mi and root.val < ans):
62101
mi = t
63102
ans = root.val
64103
if root.val > target:
@@ -72,6 +111,48 @@ class Solution:
72111

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

114+
```java
115+
/**
116+
* Definition for a binary tree node.
117+
* public class TreeNode {
118+
* int val;
119+
* TreeNode left;
120+
* TreeNode right;
121+
* TreeNode() {}
122+
* TreeNode(int val) { this.val = val; }
123+
* TreeNode(int val, TreeNode left, TreeNode right) {
124+
* this.val = val;
125+
* this.left = left;
126+
* this.right = right;
127+
* }
128+
* }
129+
*/
130+
class Solution {
131+
private int ans;
132+
private double target;
133+
private double mi = Double.MAX_VALUE;
134+
135+
public int closestValue(TreeNode root, double target) {
136+
this.target = target;
137+
dfs(root);
138+
return ans;
139+
}
140+
141+
private void dfs(TreeNode root) {
142+
if (root == null) {
143+
return;
144+
}
145+
dfs(root.left);
146+
double t = Math.abs(root.val - target);
147+
if (t < mi) {
148+
mi = t;
149+
ans = root.val;
150+
}
151+
dfs(root.right);
152+
}
153+
}
154+
```
155+
75156
```java
76157
/**
77158
* Definition for a binary tree node.
@@ -94,7 +175,7 @@ class Solution {
94175
double mi = Double.MAX_VALUE;
95176
while (root != null) {
96177
double t = Math.abs(root.val - target);
97-
if (t < mi) {
178+
if (t < mi || (t == mi && root.val < ans)) {
98179
mi = t;
99180
ans = root.val;
100181
}
@@ -109,43 +190,43 @@ class Solution {
109190
}
110191
```
111192

112-
### **JavaScript**
193+
### **C++**
113194

114-
```js
195+
```cpp
115196
/**
116197
* Definition for a binary tree node.
117-
* function TreeNode(val, left, right) {
118-
* this.val = (val===undefined ? 0 : val)
119-
* this.left = (left===undefined ? null : left)
120-
* this.right = (right===undefined ? null : right)
121-
* }
122-
*/
123-
/**
124-
* @param {TreeNode} root
125-
* @param {number} target
126-
* @return {number}
198+
* struct TreeNode {
199+
* int val;
200+
* TreeNode *left;
201+
* TreeNode *right;
202+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
203+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
204+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
205+
* };
127206
*/
128-
var closestValue = function (root, target) {
129-
let ans = root.val;
130-
let mi = Number.MAX_VALUE;
131-
while (root) {
132-
const t = Math.abs(root.val - target);
133-
if (t < mi) {
134-
mi = t;
135-
ans = root.val;
136-
}
137-
if (root.val > target) {
138-
root = root.left;
139-
} else {
140-
root = root.right;
141-
}
207+
class Solution {
208+
public:
209+
int closestValue(TreeNode* root, double target) {
210+
int ans = root->val;
211+
double mi = INT_MAX;
212+
function<void(TreeNode*)> dfs = [&](TreeNode* root) {
213+
if (!root) {
214+
return;
215+
}
216+
dfs(root->left);
217+
double t = abs(root->val - target);
218+
if (t < mi) {
219+
mi = t;
220+
ans = root->val;
221+
}
222+
dfs(root->right);
223+
};
224+
dfs(root);
225+
return ans;
142226
}
143-
return ans;
144227
};
145228
```
146229
147-
### **C++**
148-
149230
```cpp
150231
/**
151232
* Definition for a binary tree node.
@@ -165,14 +246,15 @@ public:
165246
double mi = INT_MAX;
166247
while (root) {
167248
double t = abs(root->val - target);
168-
if (t < mi) {
249+
if (t < mi || (t == mi && root->val < ans)) {
169250
mi = t;
170251
ans = root->val;
171252
}
172-
if (root->val > target)
253+
if (root->val > target) {
173254
root = root->left;
174-
else
255+
} else {
175256
root = root->right;
257+
}
176258
}
177259
return ans;
178260
}
@@ -193,12 +275,42 @@ public:
193275
func closestValue(root *TreeNode, target float64) int {
194276
ans := root.Val
195277
mi := math.MaxFloat64
196-
for root != nil {
278+
var dfs func(*TreeNode)
279+
dfs = func(root *TreeNode) {
280+
if root == nil {
281+
return
282+
}
283+
dfs(root.Left)
197284
t := math.Abs(float64(root.Val) - target)
198285
if t < mi {
199286
mi = t
200287
ans = root.Val
201288
}
289+
dfs(root.Right)
290+
}
291+
dfs(root)
292+
return ans
293+
}
294+
```
295+
296+
```go
297+
/**
298+
* Definition for a binary tree node.
299+
* type TreeNode struct {
300+
* Val int
301+
* Left *TreeNode
302+
* Right *TreeNode
303+
* }
304+
*/
305+
func closestValue(root *TreeNode, target float64) int {
306+
ans := root.Val
307+
mi := math.MaxFloat64
308+
for root != nil {
309+
t := math.Abs(float64(root.Val) - target)
310+
if t < mi || (t == mi && root.Val < ans) {
311+
mi = t
312+
ans = root.Val
313+
}
202314
if float64(root.Val) > target {
203315
root = root.Left
204316
} else {
@@ -209,6 +321,75 @@ func closestValue(root *TreeNode, target float64) int {
209321
}
210322
```
211323

324+
### **JavaScript**
325+
326+
```js
327+
/**
328+
* Definition for a binary tree node.
329+
* function TreeNode(val, left, right) {
330+
* this.val = (val===undefined ? 0 : val)
331+
* this.left = (left===undefined ? null : left)
332+
* this.right = (right===undefined ? null : right)
333+
* }
334+
*/
335+
/**
336+
* @param {TreeNode} root
337+
* @param {number} target
338+
* @return {number}
339+
*/
340+
var closestValue = function (root, target) {
341+
let mi = Infinity;
342+
let ans = root.val;
343+
const dfs = root => {
344+
if (!root) {
345+
return;
346+
}
347+
dfs(root.left);
348+
const t = Math.abs(root.val - target);
349+
if (t < mi) {
350+
mi = t;
351+
ans = root.val;
352+
}
353+
dfs(root.right);
354+
};
355+
dfs(root);
356+
return ans;
357+
};
358+
```
359+
360+
```js
361+
/**
362+
* Definition for a binary tree node.
363+
* function TreeNode(val, left, right) {
364+
* this.val = (val===undefined ? 0 : val)
365+
* this.left = (left===undefined ? null : left)
366+
* this.right = (right===undefined ? null : right)
367+
* }
368+
*/
369+
/**
370+
* @param {TreeNode} root
371+
* @param {number} target
372+
* @return {number}
373+
*/
374+
var closestValue = function (root, target) {
375+
let ans = root.val;
376+
let mi = Number.MAX_VALUE;
377+
while (root) {
378+
const t = Math.abs(root.val - target);
379+
if (t < mi || (t === mi && root.val < ans)) {
380+
mi = t;
381+
ans = root.val;
382+
}
383+
if (root.val > target) {
384+
root = root.left;
385+
} else {
386+
root = root.right;
387+
}
388+
}
389+
return ans;
390+
};
391+
```
392+
212393
### **...**
213394

214395
```

0 commit comments

Comments
 (0)