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 ee6cae6

Browse files
thinkasanyyanglbme
andauthored
feat: add solutions to lc problem: No.0270 (doocs#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‎

Lines changed: 217 additions & 36 deletions
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 < mior (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)

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