Skip to content

Commit 97de305

Browse files
YangFongYangFong
committed
feat: add solutions to lc problem: No.0215
No.0215.Kth Largest Element in an Array
1 parent 61e1f92 commit 97de305

File tree

4 files changed

+246
-0
lines changed

4 files changed

+246
-0
lines changed

‎solution/0200-0299/0215.Kth Largest Element in an Array/README.md

+96
Original file line numberDiff line numberDiff line change
@@ -171,6 +171,102 @@ func quickSort(nums []int, left, right, k int) int {
171171
}
172172
```
173173

174+
### **TypeScript**
175+
176+
```ts
177+
function findKthLargest(nums: number[], k: number): number {
178+
const n = nums.length;
179+
const swap = (i: number, j: number) => {
180+
[nums[i], nums[j]] = [nums[j], nums[i]];
181+
};
182+
const sort = (l: number, r: number) => {
183+
if (l + 1 > k || l >= r) {
184+
return;
185+
}
186+
swap(l, l + Math.floor(Math.random() * (r - l)));
187+
const num = nums[l];
188+
let mark = l;
189+
for (let i = l + 1; i < r; i++) {
190+
if (nums[i] > num) {
191+
mark++;
192+
swap(i, mark);
193+
}
194+
}
195+
swap(l, mark);
196+
197+
sort(l, mark);
198+
sort(mark + 1, r);
199+
};
200+
sort(0, n);
201+
return nums[k - 1];
202+
}
203+
```
204+
205+
### **Rust**
206+
207+
```rust
208+
use rand::Rng;
209+
210+
impl Solution {
211+
fn sort(nums: &mut Vec<i32>, l: usize, r: usize, k: usize) {
212+
if l + 1 > k || l >= r {
213+
return;
214+
}
215+
nums.swap(l, rand::thread_rng().gen_range(l, r));
216+
let num = nums[l];
217+
let mut mark = l;
218+
for i in l..r {
219+
if nums[i] > num {
220+
mark += 1;
221+
nums.swap(i, mark);
222+
}
223+
}
224+
nums.swap(l, mark);
225+
226+
Self::sort(nums, l, mark, k);
227+
Self::sort(nums, mark + 1, r, k);
228+
}
229+
230+
pub fn find_kth_largest(mut nums: Vec<i32>, k: i32) -> i32 {
231+
let n = nums.len();
232+
let k = k as usize;
233+
Self::sort(&mut nums, 0, n, k);
234+
nums[k - 1]
235+
}
236+
}
237+
```
238+
239+
```rust
240+
use rand::Rng;
241+
242+
impl Solution {
243+
pub fn find_kth_largest(mut nums: Vec<i32>, k: i32) -> i32 {
244+
let k = k as usize;
245+
let n = nums.len();
246+
let mut l = 0;
247+
let mut r = n;
248+
while l <= k - 1 && l < r {
249+
nums.swap(l, rand::thread_rng().gen_range(l, r));
250+
let num = nums[l];
251+
let mut mark = l;
252+
for i in l..r {
253+
if nums[i] > num {
254+
mark += 1;
255+
nums.swap(i, mark);
256+
}
257+
}
258+
nums.swap(l, mark);
259+
if mark + 1 <= k {
260+
l = mark + 1;
261+
} else {
262+
r = mark;
263+
}
264+
}
265+
nums[k - 1]
266+
}
267+
}
268+
```
269+
174270
### **...**
175271

176272
```

‎solution/0200-0299/0215.Kth Largest Element in an Array/README_EN.md

+96
Original file line numberDiff line numberDiff line change
@@ -153,6 +153,102 @@ func quickSort(nums []int, left, right, k int) int {
153153
}
154154
```
155155

156+
### **TypeScript**
157+
158+
```ts
159+
function findKthLargest(nums: number[], k: number): number {
160+
const n = nums.length;
161+
const swap = (i: number, j: number) => {
162+
[nums[i], nums[j]] = [nums[j], nums[i]];
163+
};
164+
const sort = (l: number, r: number) => {
165+
if (l + 1 > k || l >= r) {
166+
return;
167+
}
168+
swap(l, l + Math.floor(Math.random() * (r - l)));
169+
const num = nums[l];
170+
let mark = l;
171+
for (let i = l + 1; i < r; i++) {
172+
if (nums[i] > num) {
173+
mark++;
174+
swap(i, mark);
175+
}
176+
}
177+
swap(l, mark);
178+
179+
sort(l, mark);
180+
sort(mark + 1, r);
181+
};
182+
sort(0, n);
183+
return nums[k - 1];
184+
}
185+
```
186+
187+
### **Rust**
188+
189+
```rust
190+
use rand::Rng;
191+
192+
impl Solution {
193+
fn sort(nums: &mut Vec<i32>, l: usize, r: usize, k: usize) {
194+
if l + 1 > k || l >= r {
195+
return;
196+
}
197+
nums.swap(l, rand::thread_rng().gen_range(l, r));
198+
let num = nums[l];
199+
let mut mark = l;
200+
for i in l..r {
201+
if nums[i] > num {
202+
mark += 1;
203+
nums.swap(i, mark);
204+
}
205+
}
206+
nums.swap(l, mark);
207+
208+
Self::sort(nums, l, mark, k);
209+
Self::sort(nums, mark + 1, r, k);
210+
}
211+
212+
pub fn find_kth_largest(mut nums: Vec<i32>, k: i32) -> i32 {
213+
let n = nums.len();
214+
let k = k as usize;
215+
Self::sort(&mut nums, 0, n, k);
216+
nums[k - 1]
217+
}
218+
}
219+
```
220+
221+
```rust
222+
use rand::Rng;
223+
224+
impl Solution {
225+
pub fn find_kth_largest(mut nums: Vec<i32>, k: i32) -> i32 {
226+
let k = k as usize;
227+
let n = nums.len();
228+
let mut l = 0;
229+
let mut r = n;
230+
while l <= k - 1 && l < r {
231+
nums.swap(l, rand::thread_rng().gen_range(l, r));
232+
let num = nums[l];
233+
let mut mark = l;
234+
for i in l..r {
235+
if nums[i] > num {
236+
mark += 1;
237+
nums.swap(i, mark);
238+
}
239+
}
240+
nums.swap(l, mark);
241+
if mark + 1 <= k {
242+
l = mark + 1;
243+
} else {
244+
r = mark;
245+
}
246+
}
247+
nums[k - 1]
248+
}
249+
}
250+
```
251+
156252
### **...**
157253

158254
```

‎solution/0200-0299/0215.Kth Largest Element in an Array/Solution.rs

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
use rand::Rng;
2+
3+
impl Solution {
4+
pub fn find_kth_largest(mut nums: Vec<i32>, k: i32) -> i32 {
5+
let k = k as usize;
6+
let n = nums.len();
7+
let mut l = 0;
8+
let mut r = n;
9+
while l <= k - 1 && l < r {
10+
nums.swap(l, rand::thread_rng().gen_range(l, r));
11+
let num = nums[l];
12+
let mut mark = l;
13+
for i in l..r {
14+
if nums[i] > num {
15+
mark += 1;
16+
nums.swap(i, mark);
17+
}
18+
}
19+
nums.swap(l, mark);
20+
if mark + 1 <= k {
21+
l = mark + 1;
22+
} else {
23+
r = mark;
24+
}
25+
}
26+
nums[k - 1]
27+
}
28+
}

‎solution/0200-0299/0215.Kth Largest Element in an Array/Solution.ts

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
function findKthLargest(nums: number[], k: number): number {
2+
const n = nums.length;
3+
const swap = (i: number, j: number) => {
4+
[nums[i], nums[j]] = [nums[j], nums[i]];
5+
};
6+
const sort = (l: number, r: number) => {
7+
if (l + 1 > k || l >= r) {
8+
return;
9+
}
10+
swap(l, l + Math.floor(Math.random() * (r - l)));
11+
const num = nums[l];
12+
let mark = l;
13+
for (let i = l + 1; i < r; i++) {
14+
if (nums[i] > num) {
15+
mark++;
16+
swap(i, mark);
17+
}
18+
}
19+
swap(l, mark);
20+
21+
sort(l, mark);
22+
sort(mark + 1, r);
23+
};
24+
sort(0, n);
25+
return nums[k - 1];
26+
}

0 commit comments

Comments
 (0)