Skip to content

Commit b552939

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.270 (doocs#2874)
1 parent 200bbce commit b552939

14 files changed

+441
-371
lines changed

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

+159-139
Large diffs are not rendered by default.

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

+164-132
Large diffs are not rendered by default.

‎solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.cpp

+9-9
Original file line numberDiff line numberDiff line change
@@ -13,18 +13,18 @@ class Solution {
1313
public:
1414
int closestValue(TreeNode* root, double target) {
1515
int ans = root->val;
16-
double mi = INT_MAX;
17-
function<void(TreeNode*)> dfs = [&](TreeNode* root) {
18-
if (!root) {
16+
double diff = INT_MAX;
17+
function<void(TreeNode*)> dfs = [&](TreeNode* node) {
18+
if (!node) {
1919
return;
2020
}
21-
dfs(root->left);
22-
double t = abs(root->val - target);
23-
if (t < mi) {
24-
mi = t;
25-
ans = root->val;
21+
double nxt = abs(node->val - target);
22+
if (nxt < diff || (nxt == diff && node->val < ans)) {
23+
diff = nxt;
24+
ans = node->val;
2625
}
27-
dfs(root->right);
26+
node = target < node->val ? node->left : node->right;
27+
dfs(node);
2828
};
2929
dfs(root);
3030
return ans;

‎solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.go

+12-9
Original file line numberDiff line numberDiff line change
@@ -8,19 +8,22 @@
88
*/
99
func closestValue(root *TreeNode, target float64) int {
1010
ans := root.Val
11-
mi := math.MaxFloat64
11+
diff := math.MaxFloat64
1212
var dfs func(*TreeNode)
13-
dfs = func(root *TreeNode) {
14-
if root == nil {
13+
dfs = func(node *TreeNode) {
14+
if node == nil {
1515
return
1616
}
17-
dfs(root.Left)
18-
t := math.Abs(float64(root.Val) - target)
19-
if t < mi {
20-
mi = t
21-
ans = root.Val
17+
nxt := math.Abs(float64(node.Val) - target)
18+
if nxt < diff || (nxt == diff && node.Val < ans) {
19+
diff = nxt
20+
ans = node.Val
21+
}
22+
if target < float64(node.Val) {
23+
dfs(node.Left)
24+
} else {
25+
dfs(node.Right)
2226
}
23-
dfs(root.Right)
2427
}
2528
dfs(root)
2629
return ans

‎solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.java

+9-9
Original file line numberDiff line numberDiff line change
@@ -16,24 +16,24 @@
1616
class Solution {
1717
private int ans;
1818
private double target;
19-
private double mi = Double.MAX_VALUE;
19+
private double diff = Double.MAX_VALUE;
2020

2121
public int closestValue(TreeNode root, double target) {
2222
this.target = target;
2323
dfs(root);
2424
return ans;
2525
}
2626

27-
private void dfs(TreeNode root) {
28-
if (root == null) {
27+
private void dfs(TreeNode node) {
28+
if (node == null) {
2929
return;
3030
}
31-
dfs(root.left);
32-
double t = Math.abs(root.val - target);
33-
if (t < mi) {
34-
mi = t;
35-
ans = root.val;
31+
double nxt = Math.abs(node.val - target);
32+
if (nxt < diff || (nxt == diff && node.val < ans)) {
33+
diff = nxt;
34+
ans = node.val;
3635
}
37-
dfs(root.right);
36+
node = target < node.val ? node.left : node.right;
37+
dfs(node);
3838
}
3939
}

‎solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.js

+14-10
Original file line numberDiff line numberDiff line change
@@ -12,20 +12,24 @@
1212
* @return {number}
1313
*/
1414
var closestValue = function (root, target) {
15-
let mi = Infinity;
16-
let ans = root.val;
17-
const dfs = root => {
18-
if (!root) {
15+
let ans = 0;
16+
let diff = Infinity;
17+
18+
const dfs = node => {
19+
if (!node) {
1920
return;
2021
}
21-
dfs(root.left);
22-
const t = Math.abs(root.val - target);
23-
if (t < mi) {
24-
mi = t;
25-
ans = root.val;
22+
23+
const nxt = Math.abs(target - node.val);
24+
if (nxt < diff || (nxt === diff && node.val < ans)) {
25+
diff = nxt;
26+
ans = node.val;
2627
}
27-
dfs(root.right);
28+
29+
node = target < node.val ? node.left : node.right;
30+
dfs(node);
2831
};
32+
2933
dfs(root);
3034
return ans;
3135
};

‎solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.py

+11-10
Original file line numberDiff line numberDiff line change
@@ -6,17 +6,18 @@
66
# self.right = right
77
class Solution:
88
def closestValue(self, root: Optional[TreeNode], target: float) -> int:
9-
def dfs(root):
10-
if root is None:
9+
def dfs(node: Optional[TreeNode]):
10+
if node is None:
1111
return
12-
dfs(root.left)
13-
nonlocal ans, mi
14-
t = abs(root.val - target)
15-
if t < mi:
16-
mi = t
17-
ans = root.val
18-
dfs(root.right)
12+
nxt = abs(target - node.val)
13+
nonlocal ans, diff
14+
if nxt < diff or (nxt == diff and node.val < ans):
15+
diff = nxt
16+
ans = node.val
17+
node = node.left if target < node.val else node.right
18+
dfs(node)
1919

20-
ans, mi = root.val, inf
20+
ans = 0
21+
diff = inf
2122
dfs(root)
2223
return ans

‎solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.ts

+11-14
Original file line numberDiff line numberDiff line change
@@ -13,27 +13,24 @@
1313
*/
1414

1515
function closestValue(root: TreeNode | null, target: number): number {
16-
if (!root) return Number.NaN;
17-
18-
let res = 0;
16+
let ans = 0;
1917
let diff = Number.POSITIVE_INFINITY;
2018

21-
const dfs = (node: TreeNode | null): undefined => {
22-
if (!node) return;
23-
24-
const next = Math.abs(target - node.val);
19+
const dfs = (node: TreeNode | null): void => {
20+
if (!node) {
21+
return;
22+
}
2523

26-
if (next < diff || (next === diff && node.val < res)) {
27-
diff = next;
28-
res = node.val;
24+
const nxt = Math.abs(target - node.val);
25+
if (nxt < diff || (nxt === diff && node.val < ans)) {
26+
diff = nxt;
27+
ans = node.val;
2928
}
3029

3130
node = target < node.val ? node.left : node.right;
32-
33-
return dfs(node);
31+
dfs(node);
3432
};
3533

3634
dfs(root);
37-
38-
return res;
35+
return ans;
3936
}

‎solution/0200-0299/0270.Closest Binary Search Tree Value/Solution2.cpp

+5-9
Original file line numberDiff line numberDiff line change
@@ -13,18 +13,14 @@ class Solution {
1313
public:
1414
int closestValue(TreeNode* root, double target) {
1515
int ans = root->val;
16-
double mi = INT_MAX;
16+
double diff = INT_MAX;
1717
while (root) {
18-
double t = abs(root->val - target);
19-
if (t < mi || (t == mi && root->val < ans)) {
20-
mi = t;
18+
double nxt = abs(root->val - target);
19+
if (nxt < diff || (nxt == diff && root->val < ans)) {
20+
diff = nxt;
2121
ans = root->val;
2222
}
23-
if (root->val > target) {
24-
root = root->left;
25-
} else {
26-
root = root->right;
27-
}
23+
root = target < root->val ? root->left : root->right;
2824
}
2925
return ans;
3026
}

‎solution/0200-0299/0270.Closest Binary Search Tree Value/Solution2.go

+4-4
Original file line numberDiff line numberDiff line change
@@ -8,11 +8,11 @@
88
*/
99
func closestValue(root *TreeNode, target float64) int {
1010
ans := root.Val
11-
mi := math.MaxFloat64
11+
diff := math.MaxFloat64
1212
for root != nil {
13-
t := math.Abs(float64(root.Val) - target)
14-
if t < mi || (t == mi && root.Val < ans) {
15-
mi = t
13+
nxt := math.Abs(float64(root.Val) - target)
14+
if nxt < diff || (nxt == diff && root.Val < ans) {
15+
diff = nxt
1616
ans = root.Val
1717
}
1818
if float64(root.Val) > target {

‎solution/0200-0299/0270.Closest Binary Search Tree Value/Solution2.java

+5-9
Original file line numberDiff line numberDiff line change
@@ -16,18 +16,14 @@
1616
class Solution {
1717
public int closestValue(TreeNode root, double target) {
1818
int ans = root.val;
19-
double mi = Double.MAX_VALUE;
19+
double diff = Double.MAX_VALUE;
2020
while (root != null) {
21-
double t = Math.abs(root.val - target);
22-
if (t < mi || (t == mi && root.val < ans)) {
23-
mi = t;
21+
double nxt = Math.abs(root.val - target);
22+
if (nxt < diff || (nxt == diff && root.val < ans)) {
23+
diff = nxt;
2424
ans = root.val;
2525
}
26-
if (root.val > target) {
27-
root = root.left;
28-
} else {
29-
root = root.right;
30-
}
26+
root = target < root.val ? root.left : root.right;
3127
}
3228
return ans;
3329
}

‎solution/0200-0299/0270.Closest Binary Search Tree Value/Solution2.js

+5-9
Original file line numberDiff line numberDiff line change
@@ -13,18 +13,14 @@
1313
*/
1414
var closestValue = function (root, target) {
1515
let ans = root.val;
16-
let mi = Number.MAX_VALUE;
16+
let diff = Infinity;
1717
while (root) {
18-
const t = Math.abs(root.val - target);
19-
if (t < mi || (t === mi && root.val < ans)) {
20-
mi = t;
18+
const nxt = Math.abs(root.val - target);
19+
if (nxt < diff || (nxt === diff && root.val < ans)) {
20+
diff = nxt;
2121
ans = root.val;
2222
}
23-
if (root.val > target) {
24-
root = root.left;
25-
} else {
26-
root = root.right;
27-
}
23+
root = target < root.val ? root.left : root.right;
2824
}
2925
return ans;
3026
};

‎solution/0200-0299/0270.Closest Binary Search Tree Value/Solution2.py

+5-8
Original file line numberDiff line numberDiff line change
@@ -6,14 +6,11 @@
66
# self.right = right
77
class Solution:
88
def closestValue(self, root: Optional[TreeNode], target: float) -> int:
9-
ans, mi = root.val, inf
9+
ans, diff = root.val, inf
1010
while root:
11-
t = abs(root.val - target)
12-
if t < mi or (t == mi and root.val < ans):
13-
mi = t
11+
nxt = abs(root.val - target)
12+
if nxt < diff or (nxt == diff and root.val < ans):
13+
diff = nxt
1414
ans = root.val
15-
if root.val > target:
16-
root = root.left
17-
else:
18-
root = root.right
15+
root = root.left if target < root.val else root.right
1916
return ans

‎solution/0200-0299/0270.Closest Binary Search Tree Value/Solution2.ts

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* class TreeNode {
4+
* val: number
5+
* left: TreeNode | null
6+
* right: TreeNode | null
7+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
8+
* this.val = (val===undefined ? 0 : val)
9+
* this.left = (left===undefined ? null : left)
10+
* this.right = (right===undefined ? null : right)
11+
* }
12+
* }
13+
*/
14+
15+
function closestValue(root: TreeNode | null, target: number): number {
16+
let ans = 0;
17+
let diff = Number.POSITIVE_INFINITY;
18+
19+
while (root) {
20+
const nxt = Math.abs(root.val - target);
21+
if (nxt < diff || (nxt === diff && root.val < ans)) {
22+
diff = nxt;
23+
ans = root.val;
24+
}
25+
root = target < root.val ? root.left : root.right;
26+
}
27+
return ans;
28+
}

0 commit comments

Comments
 (0)