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 97de305

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

Lines changed: 96 additions & 0 deletions
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‎

Lines changed: 96 additions & 0 deletions
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
```
Lines changed: 28 additions & 0 deletions
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+
}
Lines changed: 26 additions & 0 deletions
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)

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