Skip to content

Commit 177ac8b

Browse files
yanglbmeyanglbme
committed
feat: update leetcode solutions: No.0783, No.0530
1 parent d0597cc commit 177ac8b

File tree

8 files changed

+293
-35
lines changed

8 files changed

+293
-35
lines changed

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

+50-1
Original file line numberDiff line numberDiff line change
@@ -39,22 +39,71 @@
3939

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

42+
中序遍历二叉搜索树，获取当前节点与上个节点的差值的最小值即可。
43+
4244
<!-- tabs:start -->
4345

4446
### **Python3**
4547

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

4850
```python
49-
51+
# Definition for a binary tree node.
52+
# class TreeNode:
53+
# def __init__(self, x):
54+
# self.val = x
55+
# self.left = None
56+
# self.right = None
57+
58+
class Solution:
59+
def getMinimumDifference(self, root: TreeNode) -> int:
60+
def inorder(root):
61+
if not root:
62+
return
63+
inorder(root.left)
64+
if self.pre is not None:
65+
self.min_diff = min(self.min_diff, abs(root.val - self.pre))
66+
self.pre = root.val
67+
inorder(root.right)
68+
69+
self.pre = None
70+
self.min_diff = 10 ** 5
71+
inorder(root)
72+
return self.min_diff
5073
```
5174

5275
### **Java**
5376

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

5679
```java
80+
/**
81+
* Definition for a binary tree node.
82+
* public class TreeNode {
83+
* int val;
84+
* TreeNode left;
85+
* TreeNode right;
86+
* TreeNode(int x) { val = x; }
87+
* }
88+
*/
89+
class Solution {
90+
91+
private int minDiff = Integer.MAX_VALUE;
92+
private Integer pre;
93+
94+
public int getMinimumDifference(TreeNode root) {
95+
inorder(root);
96+
return minDiff;
97+
}
5798

99+
private void inorder(TreeNode root) {
100+
if (root == null) return;
101+
inorder(root.left);
102+
if (pre != null) minDiff = Math.min(minDiff, Math.abs(root.val - pre));
103+
pre = root.val;
104+
inorder(root.right);
105+
}
106+
}
58107
```
59108

60109
### **Go**

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

+49-2
Original file line numberDiff line numberDiff line change
@@ -40,13 +40,60 @@ The minimum absolute difference is 1, which is the difference between 2 and 1 (o
4040
### **Python3**
4141

4242
```python
43-
43+
# Definition for a binary tree node.
44+
# class TreeNode:
45+
# def __init__(self, x):
46+
# self.val = x
47+
# self.left = None
48+
# self.right = None
49+
50+
class Solution:
51+
def getMinimumDifference(self, root: TreeNode) -> int:
52+
def inorder(root):
53+
if not root:
54+
return
55+
inorder(root.left)
56+
if self.pre is not None:
57+
self.min_diff = min(self.min_diff, abs(root.val - self.pre))
58+
self.pre = root.val
59+
inorder(root.right)
60+
61+
self.pre = None
62+
self.min_diff = 10 ** 5
63+
inorder(root)
64+
return self.min_diff
4465
```
4566

4667
### **Java**
4768

4869
```java
49-
70+
/**
71+
* Definition for a binary tree node.
72+
* public class TreeNode {
73+
* int val;
74+
* TreeNode left;
75+
* TreeNode right;
76+
* TreeNode(int x) { val = x; }
77+
* }
78+
*/
79+
class Solution {
80+
81+
private int minDiff = Integer.MAX_VALUE;
82+
private Integer pre;
83+
84+
public int getMinimumDifference(TreeNode root) {
85+
inorder(root);
86+
return minDiff;
87+
}
88+
89+
private void inorder(TreeNode root) {
90+
if (root == null) return;
91+
inorder(root.left);
92+
if (pre != null) minDiff = Math.min(minDiff, Math.abs(root.val - pre));
93+
pre = root.val;
94+
inorder(root.right);
95+
}
96+
}
5097
```
5198

5299
### **...**

‎solution/0500-0599/0530.Minimum Absolute Difference in BST/Solution.java

+14-14
Original file line numberDiff line numberDiff line change
@@ -8,20 +8,20 @@
88
* }
99
*/
1010
class Solution {
11+
12+
private int minDiff = Integer.MAX_VALUE;
13+
private Integer pre;
14+
1115
public int getMinimumDifference(TreeNode root) {
12-
Integer res = Integer.MAX_VALUE, prev = Integer.MAX_VALUE;
13-
Stack<TreeNode> stack = new Stack<>();
14-
while (true) {
15-
while (root != null) {
16-
stack.push(root);
17-
root = root.left;
18-
}
19-
if (stack.isEmpty()) break;
20-
TreeNode node = stack.pop();
21-
res = Math.min(res, Math.abs(node.val - prev));
22-
prev = node.val;
23-
root = node.right;
24-
}
25-
return res;
16+
inorder(root);
17+
return minDiff;
18+
}
19+
20+
private void inorder(TreeNode root) {
21+
if (root == null) return;
22+
inorder(root.left);
23+
if (pre != null) minDiff = Math.min(minDiff, Math.abs(root.val - pre));
24+
pre = root.val;
25+
inorder(root.right);
2626
}
2727
}

‎solution/0500-0599/0530.Minimum Absolute Difference in BST/Solution.py

+22
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
# Definition for a binary tree node.
2+
# class TreeNode:
3+
# def __init__(self, x):
4+
# self.val = x
5+
# self.left = None
6+
# self.right = None
7+
8+
class Solution:
9+
def getMinimumDifference(self, root: TreeNode) -> int:
10+
def inorder(root):
11+
if not root:
12+
return
13+
inorder(root.left)
14+
if self.pre is not None:
15+
self.min_diff = min(self.min_diff, abs(root.val - self.pre))
16+
self.pre = root.val
17+
inorder(root.right)
18+
19+
self.pre = None
20+
self.min_diff = 10 ** 5
21+
inorder(root)
22+
return self.min_diff

‎solution/0700-0799/0783.Minimum Distance Between BST Nodes/README.md

+55-1
Original file line numberDiff line numberDiff line change
@@ -40,22 +40,76 @@
4040

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

43+
中序遍历二叉搜索树，获取当前节点与上个节点的差值的最小值即可。
44+
4345
<!-- tabs:start -->
4446

4547
### **Python3**
4648

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

4951
```python
50-
52+
# Definition for a binary tree node.
53+
# class TreeNode:
54+
# def __init__(self, val=0, left=None, right=None):
55+
# self.val = val
56+
# self.left = left
57+
# self.right = right
58+
class Solution:
59+
def minDiffInBST(self, root: TreeNode) -> int:
60+
def inorder(root):
61+
if not root:
62+
return
63+
inorder(root.left)
64+
if self.pre is not None:
65+
self.min_diff = min(self.min_diff, abs(root.val - self.pre))
66+
self.pre = root.val
67+
inorder(root.right)
68+
69+
self.pre = None
70+
self.min_diff = 10 ** 5
71+
inorder(root)
72+
return self.min_diff
5173
```
5274

5375
### **Java**
5476

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

5779
```java
80+
/**
81+
* Definition for a binary tree node.
82+
* public class TreeNode {
83+
* int val;
84+
* TreeNode left;
85+
* TreeNode right;
86+
* TreeNode() {}
87+
* TreeNode(int val) { this.val = val; }
88+
* TreeNode(int val, TreeNode left, TreeNode right) {
89+
* this.val = val;
90+
* this.left = left;
91+
* this.right = right;
92+
* }
93+
* }
94+
*/
95+
class Solution {
5896

97+
private int minDiff = Integer.MAX_VALUE;
98+
private Integer pre;
99+
100+
public int minDiffInBST(TreeNode root) {
101+
inorder(root);
102+
return minDiff;
103+
}
104+
105+
private void inorder(TreeNode root) {
106+
if (root == null) return;
107+
inorder(root.left);
108+
if (pre != null) minDiff = Math.min(minDiff, Math.abs(root.val - pre));
109+
pre = root.val;
110+
inorder(root.right);
111+
}
112+
}
59113
```
60114

61115
### **Go**

‎solution/0700-0799/0783.Minimum Distance Between BST Nodes/README_EN.md

+54-2
Original file line numberDiff line numberDiff line change
@@ -40,13 +40,65 @@ while the minimum difference in this tree is 1, it occurs between node 1 and nod
4040
### **Python3**
4141

4242
```python
43-
43+
# Definition for a binary tree node.
44+
# class TreeNode:
45+
# def __init__(self, val=0, left=None, right=None):
46+
# self.val = val
47+
# self.left = left
48+
# self.right = right
49+
class Solution:
50+
def minDiffInBST(self, root: TreeNode) -> int:
51+
def inorder(root):
52+
if not root:
53+
return
54+
inorder(root.left)
55+
if self.pre is not None:
56+
self.min_diff = min(self.min_diff, abs(root.val - self.pre))
57+
self.pre = root.val
58+
inorder(root.right)
59+
60+
self.pre = None
61+
self.min_diff = 10 ** 5
62+
inorder(root)
63+
return self.min_diff
4464
```
4565

4666
### **Java**
4767

4868
```java
49-
69+
/**
70+
* Definition for a binary tree node.
71+
* public class TreeNode {
72+
* int val;
73+
* TreeNode left;
74+
* TreeNode right;
75+
* TreeNode() {}
76+
* TreeNode(int val) { this.val = val; }
77+
* TreeNode(int val, TreeNode left, TreeNode right) {
78+
* this.val = val;
79+
* this.left = left;
80+
* this.right = right;
81+
* }
82+
* }
83+
*/
84+
class Solution {
85+
86+
private int minDiff = Integer.MAX_VALUE;
87+
private Integer pre;
88+
89+
public int minDiffInBST(TreeNode root) {
90+
inorder(root);
91+
return minDiff;
92+
}
93+
94+
private void inorder(TreeNode root) {
95+
if (root == null) return;
96+
inorder(root.left);
97+
if (pre != null) minDiff = Math.min(minDiff, Math.abs(root.val - pre));
98+
pre = root.val;
99+
inorder(root.right);
100+
}
101+
}
50102
```
51103

52104
### **...**

‎solution/0700-0799/0783.Minimum Distance Between BST Nodes/Solution.java

+28-15
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,33 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* public class TreeNode {
4+
* int val;
5+
* TreeNode left;
6+
* TreeNode right;
7+
* TreeNode() {}
8+
* TreeNode(int val) { this.val = val; }
9+
* TreeNode(int val, TreeNode left, TreeNode right) {
10+
* this.val = val;
11+
* this.left = left;
12+
* this.right = right;
13+
* }
14+
* }
15+
*/
116
class Solution {
17+
18+
private int minDiff = Integer.MAX_VALUE;
19+
private Integer pre;
20+
221
public int minDiffInBST(TreeNode root) {
3-
TreeNode[] pre = new TreeNode[1];
4-
int[] res = new int[]{Integer.MAX_VALUE};
5-
dfs(root, pre, res);
6-
return res[0];
22+
inorder(root);
23+
return minDiff;
724
}
825

9-
private void dfs(TreeNode root, TreeNode[] pre, int[] res) {
10-
if (root == null) {
11-
return;
12-
}
13-
dfs(root.left, pre, res);
14-
if (pre[0] != null) {
15-
res[0] = Math.min(res[0], root.val - pre[0].val);
16-
}
17-
pre[0] = root;
18-
dfs(root.right, pre, res);
26+
private void inorder(TreeNode root) {
27+
if (root == null) return;
28+
inorder(root.left);
29+
if (pre != null) minDiff = Math.min(minDiff, Math.abs(root.val - pre));
30+
pre = root.val;
31+
inorder(root.right);
1932
}
20-
}
33+
}

0 commit comments

Comments
 (0)