feat: add ts solution to lc problem: No.0215

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

@@ -2,20 +2,27 @@ class Solution {
 public:
     int findKthLargest(vector<int>& nums, int k) {
         int n = nums.size();
-        return quickSort(nums, 0, n - 1, n - k);
+        k = n - k;
+        auto quickSort = [&](auto&& quickSort, int l, int r) -> int {
+            if (l == r) {
+                return nums[l];
+            }
+            int i = l - 1, j = r + 1;
+            int x = nums[(l + r) >> 1];
+            while (i < j) {
+                while (nums[++i] < x) {
+                }
+                while (nums[--j] > x) {
+                }
+                if (i < j) {
+                    swap(nums[i], nums[j]);
+                }
+            }
+            if (j < k) {
+                return quickSort(quickSort, j + 1, r);
+            }
+            return quickSort(quickSort, l, j);
+        };
+        return quickSort(quickSort, 0, n - 1);
     }
-
-    int quickSort(vector<int>& nums, int left, int right, int k) {
-        if (left == right) return nums[left];
-        int i = left - 1, j = right + 1;
-        int x = nums[left + right >> 1];
-        while (i < j) {
-            while (nums[++i] < x)
-                ;
-            while (nums[--j] > x)
-                ;
-            if (i < j) swap(nums[i], nums[j]);
-        }
-        return j < k ? quickSort(nums, j + 1, right, k) : quickSort(nums, left, j, k);
-    }
-};
+};

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

@@ -1,33 +1,33 @@
 func findKthLargest(nums []int, k int) int {
-	n := len(nums)
-	return quickSort(nums, 0, n-1, n-k)
-}
-
-func quickSort(nums []int, left, right, k int) int {
-	if left == right {
-		return nums[left]
-	}
-	i, j := left-1, right+1
-	x := nums[(left+right)>>1]
-	for i < j {
-		for {
-			i++
-			if nums[i] >= x {
-				break
-			}
+	k = len(nums) - k
+	var quickSort func(l, r int) int
+	quickSort = func(l, r int) int {
+		if l == r {
+			return nums[l]
 		}
-		for {
-			j--
-			if nums[j] <= x {
-				break
+		i, j := l-1, r+1
+		x := nums[(l+r)>>1]
+		for i < j {
+			for {
+				i++
+				if nums[i] >= x {
+					break
+				}
+			}
+			for {
+				j--
+				if nums[j] <= x {
+					break
+				}
+			}
+			if i < j {
+				nums[i], nums[j] = nums[j], nums[i]
 			}
 		}
-		if i < j {
-			nums[i], nums[j] = nums[j], nums[i]
+		if j < k {
+			return quickSort(j+1, r)
 		}
+		return quickSort(l, j)
 	}
-	if j < k {
-		return quickSort(nums, j+1, right, k)
-	}
-	return quickSort(nums, left, j, k)
-}
+	return quickSort(0, len(nums)-1)
+}

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

@@ -1,29 +1,33 @@
 class Solution {
+    private int[] nums;
+    private int k;
+
     public int findKthLargest(int[] nums, int k) {
-        int n = nums.length;
-        return quickSort(nums, 0, n - 1, n - k);
+        this.nums = nums;
+        this.k = nums.length - k;
+        return quickSort(0, nums.length - 1);
     }
 
-    private int quickSort(int[] nums, int left, int right, int k) {
-        if (left == right) {
-            return nums[left];
+    private int quickSort(int l, int r) {
+        if (l == r) {
+            return nums[l];
         }
-        int i = left - 1, j = right + 1;
-        int x = nums[(left + right) >>> 1];
+        int i = l - 1, j = r + 1;
+        int x = nums[(l + r) >>> 1];
         while (i < j) {
-            while (nums[++i] < x)
-                ;
-            while (nums[--j] > x)
-                ;
+            while (nums[++i] < x) {
+            }
+            while (nums[--j] > x) {
+            }
             if (i < j) {
                 int t = nums[i];
                 nums[i] = nums[j];
                 nums[j] = t;
             }
         }
         if (j < k) {
-            return quickSort(nums, j + 1, right, k);
+            return quickSort(j + 1, r);
         }
-        return quickSort(nums, left, j, k);
+        return quickSort(l, j);
     }
-}
+}

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

@@ -1,10 +1,10 @@
 class Solution:
     def findKthLargest(self, nums: List[int], k: int) -> int:
-        def quick_sort(left, right, k):
-            if left == right:
-                return nums[left]
-            i, j = left - 1, right + 1
-            x = nums[(left + right) >> 1]
+        def quick_sort(l: int, r: int) -> int:
+            if l == r:
+                return nums[l]
+            i, j = l - 1, r + 1
+            x = nums[(l + r) >> 1]
             while i < j:
                 while 1:
                     i += 1
@@ -17,8 +17,9 @@ def quick_sort(left, right, k):
                 if i < j:
                     nums[i], nums[j] = nums[j], nums[i]
             if j < k:
-                return quick_sort(j + 1, right, k)
-            return quick_sort(left, j, k)
+                return quick_sort(j + 1, r)
+            return quick_sort(l, j)
 
         n = len(nums)
-        return quick_sort(0, n - 1, n - k)
+        k = n - k
+        return quick_sort(0, n - 1)

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

@@ -1,29 +1,39 @@
-use rand::Rng;
-
 impl Solution {
-    fn sort(nums: &mut Vec<i32>, l: usize, r: usize, k: usize) {
-        if l + 1 > k || l >= r {
-            return;
+    pub fn find_kth_largest(mut nums: Vec<i32>, k: i32) -> i32 {
+        let len = nums.len();
+        let k = len - k as usize;
+        Self::quick_sort(&mut nums, 0, len - 1, k)
+    }
+
+    fn quick_sort(nums: &mut Vec<i32>, l: usize, r: usize, k: usize) -> i32 {
+        if l == r {
+            return nums[l];
         }
-        nums.swap(l, rand::thread_rng().gen_range(l, r));
-        let num = nums[l];
-        let mut mark = l;
-        for i in l..r {
-            if nums[i] > num {
-                mark += 1;
-                nums.swap(i, mark);
+
+        let (mut i, mut j) = (l as isize - 1, r as isize + 1);
+        let x = nums[(l + r) / 2];
+
+        while i < j {
+            i += 1;
+            while nums[i as usize] < x {
+                i += 1;
             }
-        }
-        nums.swap(l, mark);
 
-        Self::sort(nums, l, mark, k);
-        Self::sort(nums, mark + 1, r, k);
-    }
+            j -= 1;
+            while nums[j as usize] > x {
+                j -= 1;
+            }
 
-    pub fn find_kth_largest(mut nums: Vec<i32>, k: i32) -> i32 {
-        let n = nums.len();
-        let k = k as usize;
-        Self::sort(&mut nums, 0, n, k);
-        nums[k - 1]
+            if i < j {
+                nums.swap(i as usize, j as usize);
+            }
+        }
+
+        let j = j as usize;
+        if j < k {
+            Self::quick_sort(nums, j + 1, r, k)
+        } else {
+            Self::quick_sort(nums, l, j, k)
+        }
     }
 }

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

@@ -1,26 +1,23 @@
 function findKthLargest(nums: number[], k: number): number {
     const n = nums.length;
-    const swap = (i: number, j: number) => {
-        [nums[i], nums[j]] = [nums[j], nums[i]];
-    };
-    const sort = (l: number, r: number) => {
-        if (l + 1 > k || l >= r) {
-            return;
+    k = n - k;
+    const quickSort = (l: number, r: number): number => {
+        if (l === r) {
+            return nums[l];
         }
-        swap(l, l + Math.floor(Math.random() * (r - l)));
-        const num = nums[l];
-        let mark = l;
-        for (let i = l + 1; i < r; i++) {
-            if (nums[i] > num) {
-                mark++;
-                swap(i, mark);
+        let [i, j] = [l - 1, r + 1];
+        const x = nums[(l + r) >> 1];
+        while (i < j) {
+            while (nums[++i] < x);
+            while (nums[--j] > x);
+            if (i < j) {
+                [nums[i], nums[j]] = [nums[j], nums[i]];
             }
         }
-        swap(l, mark);
-
-        sort(l, mark);
-        sort(mark + 1, r);
+        if (j < k) {
+            return quickSort(j + 1, r);
+        }
+        return quickSort(l, j);
     };
-    sort(0, n);
-    return nums[k - 1];
+    return quickSort(0, n - 1);
 }

solution/0200-0299/0215.Kth Largest Element in an Array/Solution2.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+    int findKthLargest(vector<int>& nums, int k) {
+        priority_queue<int, vector<int>, greater<int>> minQ;
+        for (int x : nums) {
+            minQ.push(x);
+            if (minQ.size() > k) {
+                minQ.pop();
+            }
+        }
+        return minQ.top();
+    }
+};

solution/0200-0299/0215.Kth Largest Element in an Array/Solution2.go

@@ -0,0 +1,21 @@
+func findKthLargest(nums []int, k int) int {
+	minQ := hp{}
+	for _, x := range nums {
+		heap.Push(&minQ, x)
+		if minQ.Len() > k {
+			heap.Pop(&minQ)
+		}
+	}
+	return minQ.IntSlice[0]
+}
+
+type hp struct{ sort.IntSlice }
+
+func (h hp) Less(i, j int) bool { return h.IntSlice[i] < h.IntSlice[j] }
+func (h *hp) Push(v any)        { h.IntSlice = append(h.IntSlice, v.(int)) }
+func (h *hp) Pop() any {
+	a := h.IntSlice
+	v := a[len(a)-1]
+	h.IntSlice = a[:len(a)-1]
+	return v
+}

solution/0200-0299/0215.Kth Largest Element in an Array/Solution2.java

@@ -0,0 +1,12 @@
+class Solution {
+    public int findKthLargest(int[] nums, int k) {
+        PriorityQueue<Integer> minQ = new PriorityQueue<>();
+        for (int x : nums) {
+            minQ.offer(x);
+            if (minQ.size() > k) {
+                minQ.poll();
+            }
+        }
+        return minQ.peek();
+    }
+}

solution/0200-0299/0215.Kth Largest Element in an Array/Solution2.py

@@ -0,0 +1,3 @@
+class Solution:
+    def findKthLargest(self, nums: List[int], k: int) -> int:
+        return nlargest(k, nums)[-1]

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

@@ -1,28 +1,14 @@
-use rand::Rng;
+use std::collections::BinaryHeap;
 
 impl Solution {
-    pub fn find_kth_largest(mut nums: Vec<i32>, k: i32) -> i32 {
-        let k = k as usize;
-        let n = nums.len();
-        let mut l = 0;
-        let mut r = n;
-        while l <= k - 1 && l < r {
-            nums.swap(l, rand::thread_rng().gen_range(l, r));
-            let num = nums[l];
-            let mut mark = l;
-            for i in l..r {
-                if nums[i] > num {
-                    mark += 1;
-                    nums.swap(i, mark);
-                }
-            }
-            nums.swap(l, mark);
-            if mark + 1 <= k {
-                l = mark + 1;
-            } else {
-                r = mark;
+    pub fn find_kth_largest(nums: Vec<i32>, k: i32) -> i32 {
+        let mut minQ = BinaryHeap::new();
+        for &x in nums.iter() {
+            minQ.push(-x);
+            if minQ.len() > k as usize {
+                minQ.pop();
             }
         }
-        nums[k - 1]
+        -minQ.peek().unwrap()
     }
 }

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

@@ -0,0 +1,10 @@
+function findKthLargest(nums: number[], k: number): number {
+    const minQ = new MinPriorityQueue();
+    for (const x of nums) {
+        minQ.enqueue(x);
+        if (minQ.size() > k) {
+            minQ.dequeue();
+        }
+    }
+    return minQ.front().element;
+}