Skip to content

Commit 9ae273a

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problems: No.0230,0671
No.0230.Kth Smallest Element in a BST No.0671.Second Minimum Node in a Binary Tree
1 parent 99c4dd1 commit 9ae273a

File tree

12 files changed

+598
-132
lines changed

12 files changed

+598
-132
lines changed

‎solution/0200-0299/0230.Kth Smallest Element in a BST/README.md

+92-22
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
# [230. 二叉搜索树中第K小的元素](https://leetcode-cn.com/problems/kth-smallest-element-in-a-bst)
1+
# [230. 二叉搜索树中第 K 小的元素](https://leetcode-cn.com/problems/kth-smallest-element-in-a-bst)
22

33
[English Version](/solution/0200-0299/0230.Kth%20Smallest%20Element%20in%20a%20BST/README_EN.md)
44

@@ -40,7 +40,6 @@
4040

4141
<p><strong>进阶：</strong>如果二叉搜索树经常被修改（插入/删除操作）并且你需要频繁地查找第 <code>k</code> 小的值，你将如何优化算法？</p>
4242

43-
4443
## 解法
4544

4645
<!-- 这里可写通用的实现逻辑 -->
@@ -59,19 +58,20 @@
5958
# self.left = left
6059
# self.right = right
6160
class Solution:
62-
def kthSmallest(self, root: TreeNode, k: int) -> int:
63-
def inorder(root):
64-
if root is None:
65-
return
66-
inorder(root.left)
67-
self.k -= 1
68-
if self.k == 0:
69-
self.res = root.val
70-
return
71-
inorder(root.right)
72-
self.k = k
73-
inorder(root)
74-
return self.res
61+
def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
62+
def dfs(root):
63+
if root:
64+
nonlocal k, ans
65+
dfs(root.left)
66+
k -= 1
67+
if k == 0:
68+
ans = root.val
69+
return
70+
dfs(root.right)
71+
72+
ans = -1
73+
dfs(root)
74+
return ans
7575
```
7676

7777
### **Java**
@@ -96,25 +96,95 @@ class Solution:
9696
*/
9797
class Solution {
9898
private int k;
99-
private int res;
99+
private int ans;
100100

101101
public int kthSmallest(TreeNode root, int k) {
102102
this.k = k;
103-
inorder(root);
104-
return res;
103+
dfs(root);
104+
return ans;
105105
}
106106

107-
private void inorder(TreeNode root) {
107+
private void dfs(TreeNode root) {
108108
if (root == null) {
109109
return;
110110
}
111-
inorder(root.left);
111+
dfs(root.left);
112112
if (--k == 0) {
113-
res = root.val;
113+
ans = root.val;
114+
return;
115+
}
116+
dfs(root.right);
117+
}
118+
}
119+
```
120+
121+
### **C++**
122+
123+
```cpp
124+
/**
125+
* Definition for a binary tree node.
126+
* struct TreeNode {
127+
* int val;
128+
* TreeNode *left;
129+
* TreeNode *right;
130+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
131+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
132+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
133+
* };
134+
*/
135+
class Solution {
136+
public:
137+
int k;
138+
int ans;
139+
140+
int kthSmallest(TreeNode* root, int k) {
141+
this->k = k;
142+
dfs(root);
143+
return ans;
144+
}
145+
146+
void dfs(TreeNode* root) {
147+
if (!root) return;
148+
dfs(root->left);
149+
if (--k == 0)
150+
{
151+
ans = root->val;
114152
return;
115153
}
116-
inorder(root.right);
154+
dfs(root->right);
117155
}
156+
};
157+
```
158+
159+
### **Go**
160+
161+
```go
162+
/**
163+
* Definition for a binary tree node.
164+
* type TreeNode struct {
165+
* Val int
166+
* Left *TreeNode
167+
* Right *TreeNode
168+
* }
169+
*/
170+
func kthSmallest(root *TreeNode, k int) int {
171+
var ans int
172+
173+
var dfs func(root *TreeNode)
174+
dfs = func(root *TreeNode) {
175+
if root != nil {
176+
dfs(root.Left)
177+
k--
178+
if k == 0 {
179+
ans = root.Val
180+
return
181+
}
182+
dfs(root.Right)
183+
}
184+
}
185+
186+
dfs(root)
187+
return ans
118188
}
119189
```
120190

‎solution/0200-0299/0230.Kth Smallest Element in a BST/README_EN.md

+142-20
Original file line numberDiff line numberDiff line change
@@ -47,19 +47,20 @@
4747
# self.left = left
4848
# self.right = right
4949
class Solution:
50-
def kthSmallest(self, root: TreeNode, k: int) -> int:
51-
def inorder(root):
52-
if root is None:
53-
return
54-
inorder(root.left)
55-
self.k -= 1
56-
if self.k == 0:
57-
self.res = root.val
58-
return
59-
inorder(root.right)
60-
self.k = k
61-
inorder(root)
62-
return self.res
50+
def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
51+
def dfs(root):
52+
if root:
53+
nonlocal k, ans
54+
dfs(root.left)
55+
k -= 1
56+
if k == 0:
57+
ans = root.val
58+
return
59+
dfs(root.right)
60+
61+
ans = -1
62+
dfs(root)
63+
return ans
6364
```
6465

6566
### **Java**
@@ -82,28 +83,149 @@ class Solution:
8283
*/
8384
class Solution {
8485
private int k;
85-
private int res;
86+
private int ans;
8687

8788
public int kthSmallest(TreeNode root, int k) {
8889
this.k = k;
89-
inorder(root);
90-
return res;
90+
dfs(root);
91+
return ans;
9192
}
9293

93-
private void inorder(TreeNode root) {
94+
private void dfs(TreeNode root) {
9495
if (root == null) {
9596
return;
9697
}
97-
inorder(root.left);
98+
dfs(root.left);
9899
if (--k == 0) {
99-
res = root.val;
100+
ans = root.val;
100101
return;
101102
}
102-
inorder(root.right);
103+
dfs(root.right);
103104
}
104105
}
105106
```
106107

108+
```java
109+
/**
110+
* Definition for a binary tree node.
111+
* public class TreeNode {
112+
* int val;
113+
* TreeNode left;
114+
* TreeNode right;
115+
* TreeNode() {}
116+
* TreeNode(int val) { this.val = val; }
117+
* TreeNode(int val, TreeNode left, TreeNode right) {
118+
* this.val = val;
119+
* this.left = left;
120+
* this.right = right;
121+
* }
122+
* }
123+
*/
124+
class Solution {
125+
public int kthSmallest(TreeNode root, int k) {
126+
int ans = -1;
127+
while (root != null) {
128+
if (root.left == null) {
129+
--k;
130+
if (k == 0) {
131+
ans = root.val;
132+
return ans;
133+
}
134+
root = root.right;
135+
} else {
136+
TreeNode pre = root.left;
137+
while (pre.right != null && pre.right != root) {
138+
pre = pre.right;
139+
}
140+
if (pre.right == null) {
141+
pre.right = root;
142+
root = root.left;
143+
} else {
144+
--k;
145+
if (k == 0) {
146+
ans = root.val;
147+
return ans;
148+
}
149+
pre.right = null;
150+
root = root.right;
151+
}
152+
}
153+
}
154+
return ans;
155+
}
156+
}
157+
```
158+
159+
### **C++**
160+
161+
```cpp
162+
/**
163+
* Definition for a binary tree node.
164+
* struct TreeNode {
165+
* int val;
166+
* TreeNode *left;
167+
* TreeNode *right;
168+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
169+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
170+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
171+
* };
172+
*/
173+
class Solution {
174+
public:
175+
int k;
176+
int ans;
177+
178+
int kthSmallest(TreeNode* root, int k) {
179+
this->k = k;
180+
dfs(root);
181+
return ans;
182+
}
183+
184+
void dfs(TreeNode* root) {
185+
if (!root) return;
186+
dfs(root->left);
187+
if (--k == 0)
188+
{
189+
ans = root->val;
190+
return;
191+
}
192+
dfs(root->right);
193+
}
194+
};
195+
```
196+
197+
### **Go**
198+
199+
```go
200+
/**
201+
* Definition for a binary tree node.
202+
* type TreeNode struct {
203+
* Val int
204+
* Left *TreeNode
205+
* Right *TreeNode
206+
* }
207+
*/
208+
func kthSmallest(root *TreeNode, k int) int {
209+
var ans int
210+
211+
var dfs func(root *TreeNode)
212+
dfs = func(root *TreeNode) {
213+
if root != nil {
214+
dfs(root.Left)
215+
k--
216+
if k == 0 {
217+
ans = root.Val
218+
return
219+
}
220+
dfs(root.Right)
221+
}
222+
}
223+
224+
dfs(root)
225+
return ans
226+
}
227+
```
228+
107229
### **...**
108230

109231
```

‎solution/0200-0299/0230.Kth Smallest Element in a BST/Solution.cpp

+33
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10+
* };
11+
*/
12+
class Solution {
13+
public:
14+
int k;
15+
int ans;
16+
17+
int kthSmallest(TreeNode* root, int k) {
18+
this->k = k;
19+
dfs(root);
20+
return ans;
21+
}
22+
23+
void dfs(TreeNode* root) {
24+
if (!root) return;
25+
dfs(root->left);
26+
if (--k == 0)
27+
{
28+
ans = root->val;
29+
return;
30+
}
31+
dfs(root->right);
32+
}
33+
};

0 commit comments

Comments
 (0)