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 177c878

Browse files
feat: update solutions to lc problem: No.0530,0537,0783 (doocs#3318)
* No.0537.Complex Number Multiplication * No.0530.Minimum Absolute Difference in BST * No.0783.Minimum Distance Between BST Nodes
1 parent 173bc81 commit 177c878

File tree

25 files changed

+722
-463
lines changed

25 files changed

+722
-463
lines changed

‎solution/0500-0599/0530.Minimum Absolute Difference in BST/README.md‎

Lines changed: 102 additions & 85 deletions
Original file line numberDiff line numberDiff line change
@@ -61,7 +61,11 @@ tags:
6161

6262
### 方法一:中序遍历
6363

64-
中序遍历二叉搜索树,获取当前节点与上个节点差值的最小值即可。
64+
题目需要我们求任意两个节点值之间的最小差值,而二叉搜索树的中序遍历是一个递增序列,因此我们只需要求中序遍历中相邻两个节点值之间的最小差值即可。
65+
66+
我们可以使用递归的方法来实现中序遍历,过程中用一个变量 $\textit{pre}$ 来保存前一个节点的值,这样我们就可以在遍历的过程中求出相邻两个节点值之间的最小差值。
67+
68+
时间复杂度 $O(n),ドル空间复杂度 $O(n)$。其中 $n$ 为二叉搜索树的节点个数。
6569

6670
<!-- tabs:start -->
6771

@@ -75,17 +79,18 @@ tags:
7579
# self.left = left
7680
# self.right = right
7781
class Solution:
78-
def getMinimumDifference(self, root: TreeNode) -> int:
79-
def dfs(root):
82+
def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
83+
def dfs(root: Optional[TreeNode]):
8084
if root is None:
8185
return
8286
dfs(root.left)
83-
nonlocal ans, prev
84-
ans = min(ans, abs(prev -root.val))
85-
prev = root.val
87+
nonlocal pre, ans
88+
ans = min(ans, root.val- pre)
89+
pre = root.val
8690
dfs(root.right)
8791

88-
ans = prev = inf
92+
pre = -inf
93+
ans = inf
8994
dfs(root)
9095
return ans
9196
```
@@ -109,13 +114,11 @@ class Solution:
109114
* }
110115
*/
111116
class Solution {
112-
private int ans;
113-
private int prev;
114-
private int inf = Integer.MAX_VALUE;
117+
private finalint inf =1<<30;
118+
private int ans = inf;
119+
private int pre = -inf;
115120

116121
public int getMinimumDifference(TreeNode root) {
117-
ans = inf;
118-
prev = inf;
119122
dfs(root);
120123
return ans;
121124
}
@@ -125,8 +128,8 @@ class Solution {
125128
return;
126129
}
127130
dfs(root.left);
128-
ans = Math.min(ans, Math.abs(root.val - prev));
129-
prev = root.val;
131+
ans = Math.min(ans, root.val - pre);
132+
pre = root.val;
130133
dfs(root.right);
131134
}
132135
}
@@ -148,23 +151,21 @@ class Solution {
148151
*/
149152
class Solution {
150153
public:
151-
const int inf = INT_MAX;
152-
int ans;
153-
int prev;
154-
155154
int getMinimumDifference(TreeNode* root) {
156-
ans = inf, prev = inf;
157-
dfs(root);
155+
const int inf = 1 << 30;
156+
int ans = inf, pre = -inf;
157+
auto dfs = [&](auto&& dfs, TreeNode* root) -> void {
158+
if (!root) {
159+
return;
160+
}
161+
dfs(dfs, root->left);
162+
ans = min(ans, root->val - pre);
163+
pre = root->val;
164+
dfs(dfs, root->right);
165+
};
166+
dfs(dfs, root);
158167
return ans;
159168
}
160-
161-
void dfs(TreeNode* root) {
162-
if (!root) return;
163-
dfs(root->left);
164-
ans = min(ans, abs(prev - root->val));
165-
prev = root->val;
166-
dfs(root->right);
167-
}
168169
};
169170
```
170171
@@ -180,27 +181,53 @@ public:
180181
* }
181182
*/
182183
func getMinimumDifference(root *TreeNode) int {
183-
inf := 0x3f3f3f3f
184-
ans, prev := inf, inf
184+
const inf int = 1 << 30
185+
ans, pre := inf, -inf
185186
var dfs func(*TreeNode)
186187
dfs = func(root *TreeNode) {
187188
if root == nil {
188189
return
189190
}
190191
dfs(root.Left)
191-
ans = min(ans, abs(prev-root.Val))
192-
prev = root.Val
192+
ans = min(ans, root.Val-pre)
193+
pre = root.Val
193194
dfs(root.Right)
194195
}
195196
dfs(root)
196197
return ans
197198
}
199+
```
198200

199-
func abs(x int) int {
200-
if x < 0 {
201-
return -x
202-
}
203-
return x
201+
#### TypeScript
202+
203+
```ts
204+
/**
205+
* Definition for a binary tree node.
206+
* class TreeNode {
207+
* val: number
208+
* left: TreeNode | null
209+
* right: TreeNode | null
210+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
211+
* this.val = (val===undefined ? 0 : val)
212+
* this.left = (left===undefined ? null : left)
213+
* this.right = (right===undefined ? null : right)
214+
* }
215+
* }
216+
*/
217+
218+
function getMinimumDifference(root: TreeNode | null): number {
219+
let [ans, pre] = [Infinity, -Infinity];
220+
const dfs = (root: TreeNode | null) => {
221+
if (!root) {
222+
return;
223+
}
224+
dfs(root.left);
225+
ans = Math.min(ans, root.val - pre);
226+
pre = root.val;
227+
dfs(root.right);
228+
};
229+
dfs(root);
230+
return ans;
204231
}
205232
```
206233

@@ -225,69 +252,59 @@ func abs(x int) int {
225252
// }
226253
// }
227254
// }
228-
use std::cell::RefCell;
229255
use std::rc::Rc;
256+
use std::cell::RefCell;
230257
impl Solution {
231-
#[allow(dead_code)]
232258
pub fn get_minimum_difference(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
233-
let mut ret = i32::MAX;
234-
let mut prev = i32::MAX;
235-
Self::traverse(root, &mut prev, &mut ret);
236-
ret
237-
}
238-
239-
#[allow(dead_code)]
240-
fn traverse(root: Option<Rc<RefCell<TreeNode>>>, prev: &mut i32, ans: &mut i32) {
241-
let left = root.as_ref().unwrap().borrow().left.clone();
242-
let right = root.as_ref().unwrap().borrow().right.clone();
243-
let val = root.as_ref().unwrap().borrow().val;
244-
if !left.is_none() {
245-
Self::traverse(left.clone(), prev, ans);
246-
}
247-
*ans = std::cmp::min(*ans, (*prev - val).abs());
248-
*prev = val;
249-
if !right.is_none() {
250-
Self::traverse(right.clone(), prev, ans);
259+
const inf: i32 = 1 << 30;
260+
let mut ans = inf;
261+
let mut pre = -inf;
262+
263+
fn dfs(node: Option<Rc<RefCell<TreeNode>>>, ans: &mut i32, pre: &mut i32) {
264+
if let Some(n) = node {
265+
let n = n.borrow();
266+
dfs(n.left.clone(), ans, pre);
267+
*ans = (*ans).min(n.val - *pre);
268+
*pre = n.val;
269+
dfs(n.right.clone(), ans, pre);
270+
}
251271
}
272+
273+
dfs(root, &mut ans, &mut pre);
274+
ans
252275
}
253276
}
254277
```
255278

256-
#### TypeScript
279+
#### JavaScript
257280

258-
```ts
281+
```js
259282
/**
260283
* Definition for a binary tree node.
261-
* class TreeNode {
262-
* val: number
263-
* left: TreeNode | null
264-
* right: TreeNode | null
265-
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
266-
* this.val = (val===undefined ? 0 : val)
267-
* this.left = (left===undefined ? null : left)
268-
* this.right = (right===undefined ? null : right)
269-
* }
284+
* function TreeNode(val, left, right) {
285+
* this.val = (val===undefined ? 0 : val)
286+
* this.left = (left===undefined ? null : left)
287+
* this.right = (right===undefined ? null : right)
270288
* }
271289
*/
272-
function getMinimumDifference(root: TreeNode | null): number {
273-
if (!root) return 0;
274-
275-
let prev = Number.MIN_SAFE_INTEGER;
276-
let min = Number.MAX_SAFE_INTEGER;
277-
278-
const dfs = (node: TreeNode | null) => {
279-
if (!node) return;
280-
281-
dfs(node.left);
282-
min = Math.min(min, node.val - prev);
283-
prev = node.val;
284-
dfs(node.right);
290+
/**
291+
* @param {TreeNode} root
292+
* @return {number}
293+
*/
294+
var getMinimumDifference = function (root) {
295+
let [ans, pre] = [Infinity, -Infinity];
296+
const dfs = root => {
297+
if (!root) {
298+
return;
299+
}
300+
dfs(root.left);
301+
ans = Math.min(ans, root.val - pre);
302+
pre = root.val;
303+
dfs(root.right);
285304
};
286-
287305
dfs(root);
288-
289-
return min;
290-
}
306+
return ans;
307+
};
291308
```
292309

293310
<!-- tabs:end -->

0 commit comments

Comments
(0)

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