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 9ae273a

Browse files
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‎

Lines changed: 92 additions & 22 deletions
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‎

Lines changed: 142 additions & 20 deletions
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
```
Lines changed: 33 additions & 0 deletions
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)

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