Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

feat: add solutions to lc problem: No.0270 #1557

Merged
merged 3 commits into from
Sep 1, 2023
Merged

feat: add solutions to lc problem: No.0270 #1557

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
cb9748a
feat: add js solution to lc problem: No.270
thinkasany Aug 31, 2023
36673be
feat: add solutions to lc problem: No.0270
yanglbme Sep 1, 2023
2839728
Merge branch 'main' into dev-think
yanglbme Sep 1, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
253 changes: 217 additions & 36 deletions solution/0200-0299/0270.Closest Binary Search Tree Value/README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -38,14 +38,53 @@

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

二分查找。
**方法一：中序遍历**

我们用一个变量 $mi$ 维护最小的差值，用一个变量 $ans$ 维护答案。初始时 $mi=\infty$, $ans=root.val$。

接下来，进行中序遍历，每次计算当前节点与目标值 $target$ 的差的绝对值 $t$。如果 $t \lt mi$，或者 $t = mi$ 且当前节点的值小于 $ans$，则更新 $mi$ 和 $ans$。

时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉搜索树的节点数。

**方法二：二分查找**

与方法一类似，我们用一个变量 $mi$ 维护最小的差值，用一个变量 $ans$ 维护答案。初始时 $mi=\infty$, $ans=root.val$。

接下来，进行二分查找，每次计算当前节点与目标值 $target$ 的差的绝对值 $t$。如果 $t \lt mi$，或者 $t = mi$ 且当前节点的值小于 $ans$，则更新 $mi$ 和 $ans$。如果当前节点的值大于 $target$，则查找左子树，否则查找右子树。当我们遍历到叶子节点时，就可以结束二分查找了。

时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 是二叉搜索树的节点数。

<!-- tabs:start -->

### **Python3**

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

```python
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def closestValue(self, root: Optional[TreeNode], target: float) -> int:
def dfs(root):
if root is None:
return
dfs(root.left)
nonlocal ans, mi
t = abs(root.val - target)
if t < mi:
mi = t
ans = root.val
dfs(root.right)

ans, mi = root.val, inf
dfs(root)
return ans
```

```python
# Definition for a binary tree node.
# class TreeNode:
Expand All @@ -58,7 +97,7 @@ class Solution:
ans, mi = root.val, inf
while root:
t = abs(root.val - target)
if t < mi:
if t < mi or (t == mi and root.val < ans):
mi = t
ans = root.val
if root.val > target:
Expand All @@ -72,6 +111,48 @@ class Solution:

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

```java
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
private int ans;
private double target;
private double mi = Double.MAX_VALUE;

public int closestValue(TreeNode root, double target) {
this.target = target;
dfs(root);
return ans;
}

private void dfs(TreeNode root) {
if (root == null) {
return;
}
dfs(root.left);
double t = Math.abs(root.val - target);
if (t < mi) {
mi = t;
ans = root.val;
}
dfs(root.right);
}
}
```

```java
/**
* Definition for a binary tree node.
Expand All @@ -94,7 +175,7 @@ class Solution {
double mi = Double.MAX_VALUE;
while (root != null) {
double t = Math.abs(root.val - target);
if (t < mi) {
if (t < mi || (t == mi && root.val < ans)) {
mi = t;
ans = root.val;
}
Expand All @@ -109,43 +190,43 @@ class Solution {
}
```

### **JavaScript**
### **C++**

```js
```cpp
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @param {number} target
* @return {number}
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
var closestValue = function (root, target) {
let ans = root.val;
let mi = Number.MAX_VALUE;
while (root) {
const t = Math.abs(root.val - target);
if (t < mi) {
mi = t;
ans = root.val;
}
if (root.val > target) {
root = root.left;
} else {
root = root.right;
}
class Solution {
public:
int closestValue(TreeNode* root, double target) {
int ans = root->val;
double mi = INT_MAX;
function<void(TreeNode*)> dfs = [&](TreeNode* root) {
if (!root) {
return;
}
dfs(root->left);
double t = abs(root->val - target);
if (t < mi) {
mi = t;
ans = root->val;
}
dfs(root->right);
};
dfs(root);
return ans;
}
return ans;
};
```

### **C++**

```cpp
/**
* Definition for a binary tree node.
Expand All @@ -165,14 +246,15 @@ public:
double mi = INT_MAX;
while (root) {
double t = abs(root->val - target);
if (t < mi) {
if (t < mi || (t == mi && root->val < ans)) {
mi = t;
ans = root->val;
}
if (root->val > target)
if (root->val > target) {
root = root->left;
else
} else {
root = root->right;
}
}
return ans;
}
Expand All @@ -193,12 +275,42 @@ public:
func closestValue(root *TreeNode, target float64) int {
ans := root.Val
mi := math.MaxFloat64
for root != nil {
var dfs func(*TreeNode)
dfs = func(root *TreeNode) {
if root == nil {
return
}
dfs(root.Left)
t := math.Abs(float64(root.Val) - target)
if t < mi {
mi = t
ans = root.Val
}
dfs(root.Right)
}
dfs(root)
return ans
}
```

```go
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func closestValue(root *TreeNode, target float64) int {
ans := root.Val
mi := math.MaxFloat64
for root != nil {
t := math.Abs(float64(root.Val) - target)
if t < mi || (t == mi && root.Val < ans) {
mi = t
ans = root.Val
}
if float64(root.Val) > target {
root = root.Left
} else {
Expand All @@ -209,6 +321,75 @@ func closestValue(root *TreeNode, target float64) int {
}
```

### **JavaScript**

```js
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @param {number} target
* @return {number}
*/
var closestValue = function (root, target) {
let mi = Infinity;
let ans = root.val;
const dfs = root => {
if (!root) {
return;
}
dfs(root.left);
const t = Math.abs(root.val - target);
if (t < mi) {
mi = t;
ans = root.val;
}
dfs(root.right);
};
dfs(root);
return ans;
};
```

```js
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @param {number} target
* @return {number}
*/
var closestValue = function (root, target) {
let ans = root.val;
let mi = Number.MAX_VALUE;
while (root) {
const t = Math.abs(root.val - target);
if (t < mi || (t === mi && root.val < ans)) {
mi = t;
ans = root.val;
}
if (root.val > target) {
root = root.left;
} else {
root = root.right;
}
}
return ans;
};
```

### **...**

```
Expand Down
Loading