Skip to content

Commit 3d7241b

Browse files
yanglbmeyanglbme
committed
feat: update solutions to lcof problem: No.054. Kth Largest
1 parent a450b38 commit 3d7241b

File tree

6 files changed

+153
-101
lines changed

6 files changed

+153
-101
lines changed

‎lcof/面试题54. 二叉搜索树的第k大节点/README.md

+76-49
Original file line numberDiff line numberDiff line change
@@ -51,20 +51,20 @@
5151
# self.right = None
5252

5353
class Solution:
54-
t, res = 0, -1
5554
def kthLargest(self, root: TreeNode, k: int) -> int:
56-
self.t = k
57-
self._traverse(root)
58-
return self.res
59-
60-
def _traverse(self, node):
61-
if node:
62-
self._traverse(node.right)
63-
self.t -= 1
64-
if self.t == 0:
65-
self.res = node.val
55+
def inorder(root):
56+
if root is None:
57+
return
58+
inorder(root.right)
59+
self.cur -= 1
60+
if self.cur == 0:
61+
self.res = root.val
6662
return
67-
self._traverse(node.left)
63+
inorder(root.left)
64+
65+
self.cur = k
66+
inorder(root)
67+
return self.res
6868
```
6969

7070
### **Java**
@@ -80,24 +80,27 @@ class Solution:
8080
* }
8181
*/
8282
class Solution {
83-
private int t;
83+
private int cur;
8484
private int res;
85+
8586
public int kthLargest(TreeNode root, int k) {
86-
t = k;
87-
traverse(root);
87+
cur = k;
88+
res = 0;
89+
inorder(root);
8890
return res;
8991
}
9092

91-
private void traverse(TreeNode node) {
92-
if (node != null) {
93-
traverse(node.right);
94-
--t;
95-
if (t == 0) {
96-
res = node.val;
97-
return;
98-
}
99-
traverse(node.left);
93+
private void inorder(TreeNode root) {
94+
if (root == null) {
95+
return;
96+
}
97+
inorder(root.right);
98+
--cur;
99+
if (cur == 0) {
100+
res = root.val;
101+
return;
100102
}
103+
inorder(root.left);
101104
}
102105
}
103106
```
@@ -117,44 +120,60 @@ class Solution {
117120
* @param {number} k
118121
* @return {number}
119122
*/
120-
var kthLargest = function (root, k) {
121-
let res;
122-
let t = 0;
123-
function traversal(node) {
124-
if (!node) return;
125-
traversal(node.right);
126-
if (++t === k) res = node.val;
127-
traversal(node.left);
128-
}
129-
traversal(root);
130-
return res;
123+
var kthLargest = function(root, k) {
124+
const inorder = (root) => {
125+
if (!root) {
126+
return;
127+
}
128+
inorder(root.right);
129+
--cur;
130+
if (cur == 0) {
131+
res = root.val;
132+
return;
133+
}
134+
inorder(root.left);
135+
}
136+
let res = 0;
137+
let cur = k;
138+
inorder(root);
139+
return res;
131140
};
132141
```
133142

134143
### **C++**
135144

136145
```cpp
146+
/**
147+
* Definition for a binary tree node.
148+
* struct TreeNode {
149+
* int val;
150+
* TreeNode *left;
151+
* TreeNode *right;
152+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
153+
* };
154+
*/
137155
class Solution {
138156
public:
139157
int kthLargest(TreeNode* root, int k) {
140158
cur = k;
141-
inOrder(root);
159+
inorder(root);
142160
return res;
143161
}
144162

145163
private:
146164
int cur, res;
147165

148-
void inOrder(TreeNode* root) {
149-
if (root) {
150-
inOrder(root->right);
151-
--cur;
152-
if (cur == 0) {
153-
res = root->val;
154-
return;
155-
}
156-
inOrder(root->left);
166+
void inorder(TreeNode* root) {
167+
if (!root) {
168+
return;
157169
}
170+
inorder(root->right);
171+
--cur;
172+
if (cur == 0) {
173+
res = root->val;
174+
return;
175+
}
176+
inorder(root->left);
158177
}
159178
};
160179
```
@@ -164,26 +183,34 @@ private:
164183
利用 Go 的特性，中序遍历“生产”的数字传到 `channel`，返回第 `k` 个。
165184
166185
```go
186+
/**
187+
* Definition for a binary tree node.
188+
* type TreeNode struct {
189+
* Val int
190+
* Left *TreeNode
191+
* Right *TreeNode
192+
* }
193+
*/
167194
func kthLargest(root *TreeNode, k int) int {
168195
ch := make(chan int)
169196
ctx, cancel := context.WithCancel(context.Background())
170197
defer cancel()
171-
go inOrder(ctx, root, ch)
198+
go inorder(ctx, root, ch)
172199
for ; k > 1; k-- {
173200
<-ch
174201
}
175202
return <-ch
176203
}
177204
178-
func inOrder(ctx context.Context, cur *TreeNode, ch chan<- int) {
205+
func inorder(ctx context.Context, cur *TreeNode, ch chan<- int) {
179206
if cur != nil {
180-
inOrder(ctx, cur.Right, ch)
207+
inorder(ctx, cur.Right, ch)
181208
select {
182209
case ch <- cur.Val:
183210
case <-ctx.Done():
184211
return
185212
}
186-
inOrder(ctx, cur.Left, ch)
213+
inorder(ctx, cur.Left, ch)
187214
}
188215
}
189216
```

‎lcof/面试题54. 二叉搜索树的第k大节点/Solution.cpp

+21-11
Original file line numberDiff line numberDiff line change
@@ -1,23 +1,33 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8+
* };
9+
*/
110
class Solution {
211
public:
312
int kthLargest(TreeNode* root, int k) {
413
cur = k;
5-
inOrder(root);
14+
inorder(root);
615
return res;
716
}
817

918
private:
1019
int cur, res;
1120

12-
void inOrder(TreeNode* root) {
13-
if (root) {
14-
inOrder(root->right);
15-
--cur;
16-
if (cur == 0) {
17-
res = root->val;
18-
return;
19-
}
20-
inOrder(root->left);
21+
void inorder(TreeNode* root) {
22+
if (!root) {
23+
return;
2124
}
25+
inorder(root->right);
26+
--cur;
27+
if (cur == 0) {
28+
res = root->val;
29+
return;
30+
}
31+
inorder(root->left);
2232
}
23-
};
33+
};

‎lcof/面试题54. 二叉搜索树的第k大节点/Solution.go

+13-5
Original file line numberDiff line numberDiff line change
@@ -1,22 +1,30 @@
1-
func kthLargest(root *TreeNode, k int) int {
1+
/**
2+
* Definition for a binary tree node.
3+
* type TreeNode struct {
4+
* Val int
5+
* Left *TreeNode
6+
* Right *TreeNode
7+
* }
8+
*/
9+
func kthLargest(root *TreeNode, k int) int {
210
ch := make(chan int)
311
ctx, cancel := context.WithCancel(context.Background())
412
defer cancel()
5-
go inOrder(ctx, root, ch)
13+
go inorder(ctx, root, ch)
614
for ; k > 1; k-- {
715
<-ch
816
}
917
return <-ch
1018
}
1119

12-
func inOrder(ctx context.Context, cur *TreeNode, ch chan<- int) {
20+
func inorder(ctx context.Context, cur *TreeNode, ch chan<- int) {
1321
if cur != nil {
14-
inOrder(ctx, cur.Right, ch)
22+
inorder(ctx, cur.Right, ch)
1523
select {
1624
case ch <- cur.Val:
1725
case <-ctx.Done():
1826
return
1927
}
20-
inOrder(ctx, cur.Left, ch)
28+
inorder(ctx, cur.Left, ch)
2129
}
2230
}

‎lcof/面试题54. 二叉搜索树的第k大节点/Solution.java

+15-12
Original file line numberDiff line numberDiff line change
@@ -8,23 +8,26 @@
88
* }
99
*/
1010
class Solution {
11-
private int t;
11+
private int cur;
1212
private int res;
13+
1314
public int kthLargest(TreeNode root, int k) {
14-
t = k;
15-
traverse(root);
15+
cur = k;
16+
res = 0;
17+
inorder(root);
1618
return res;
1719
}
1820

19-
private void traverse(TreeNode node) {
20-
if (node != null) {
21-
traverse(node.right);
22-
--t;
23-
if (t == 0) {
24-
res = node.val;
25-
return;
26-
}
27-
traverse(node.left);
21+
private void inorder(TreeNode root) {
22+
if (root == null) {
23+
return;
24+
}
25+
inorder(root.right);
26+
--cur;
27+
if (cur == 0) {
28+
res = root.val;
29+
return;
2830
}
31+
inorder(root.left);
2932
}
3033
}

‎lcof/面试题54. 二叉搜索树的第k大节点/Solution.js

+16-10
Original file line numberDiff line numberDiff line change
@@ -10,15 +10,21 @@
1010
* @param {number} k
1111
* @return {number}
1212
*/
13-
var kthLargest = function (root, k) {
14-
let res;
15-
let t = 0;
16-
function traversal(node) {
17-
if (!node) return;
18-
traversal(node.right);
19-
if (++t === k) res = node.val;
20-
traversal(node.left);
13+
var kthLargest = function(root, k) {
14+
const inorder = (root) => {
15+
if (!root) {
16+
return;
17+
}
18+
inorder(root.right);
19+
--cur;
20+
if (cur == 0) {
21+
res = root.val;
22+
return;
23+
}
24+
inorder(root.left);
2125
}
22-
traversal(root);
26+
let res = 0;
27+
let cur = k;
28+
inorder(root);
2329
return res;
24-
};
30+
};

‎lcof/面试题54. 二叉搜索树的第k大节点/Solution.py

+12-14
Original file line numberDiff line numberDiff line change
@@ -5,20 +5,18 @@
55
# self.left = None
66
# self.right = None
77

8-
98
class Solution:
10-
t, res = 0, -1
11-
129
def kthLargest(self, root: TreeNode, k: int) -> int:
13-
self.t = k
14-
self._traverse(root)
15-
return self.res
16-
17-
def _traverse(self, node):
18-
if node:
19-
self._traverse(node.right)
20-
self.t -= 1
21-
if self.t == 0:
22-
self.res = node.val
10+
def inorder(root):
11+
if root is None:
2312
return
24-
self._traverse(node.left)
13+
inorder(root.right)
14+
self.cur -= 1
15+
if self.cur == 0:
16+
self.res = root.val
17+
return
18+
inorder(root.left)
19+
20+
self.cur = k
21+
inorder(root)
22+
return self.res

0 commit comments

Comments
 (0)