215_Kth_Largest_Element_in_an_Array

qiyuangong · qiyuangong · commit adbe57ffee34 · 2018-12-02T20:55:57.000+08:00
diff --git a/README.md b/README.md
@@ -80,6 +80,7 @@ Also, there are open source implementations for basic data structs and algorithm
 | 200 | [Number of Islands](https://leetcode.com/problems/number-of-islands/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/200_Number_of_Islands.py) | 1. Quick union find, O(nlogn) and O(n^2)<br>2. BFS with marks, O(n^2) and O(1) |
 | 206 | [Reverse Linked List](https://leetcode.com/problems/reverse-linked-list/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/206_Reverse_Linked_List.py) | 1. Stack, O(n) and O(n)<br>2. Traverse on prev and curr, then curr.next = prev, O(n) and O(1)<br>3. Recursion, O(n) and O(1) | 
 | 213 | [House Robber II](https://leetcode.com/problems/house-robber-ii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/213_House_Robber_II.py) | f(k) = max(f(k – 2) + num[k], max(dp[0~ls-2],dp[1~ls-1], O(n) and O(1)|
+| 215 | [Kth Largest Element in an Array](https://leetcode.com/problems/kth-largest-element-in-an-array/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/215_Kth_Largest_Element_in_an_Array.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/215_Kth_Largest_Element_in_an_Array.java) | 1. Sort, O(n) and O(n)<br>2. Heap, O(nlgk) and O(n)<br>3. Quick selection, O(klgn) and O(n)|
 | 216 | [Combination Sum III](https://leetcode.com/problems/combination-sum-iii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/216_Combination_Sum_III.py) | Generate all combinations of length k and keep those that sum to n|
 | 217 | [Contains Duplicate](https://leetcode.com/problems/contains-duplicate/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/217_Contains_Duplicate.py) | 1. Set and compare length<br>2. Sort and check i,i +1|
 | 219 | [Contains Duplicate II](https://leetcode.com/problems/contains-duplicate-ii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/219_Contains_Duplicate_II.py) | 1. Brute force<br> 2. Maintenance a set that contains previous k numbers, and check if curr in set |
diff --git a/java/215_Kth_Largest_Element_in_an_Array.java b/java/215_Kth_Largest_Element_in_an_Array.java
@@ -0,0 +1,55 @@
+class Solution {
+    public int findKthLargest(int[] nums, int k) {
+        //https://leetcode.com/problems/kth-largest-element-in-an-array/discuss/60294/Solution-explained
+        // shuffle nums to avoid n * n
+        shuffle(nums);
+        k = nums.length - k;
+        int lo = 0;
+        int hi = nums.length - 1;
+        while (lo < hi) {
+            final int j = partition(nums, lo, hi);
+            if(j < k) {
+                lo = j + 1;
+            } else if (j > k) {
+                hi = j - 1;
+            } else {
+                break;
+            }
+        }
+        return nums[k];
+    }
+
+    private int partition(int[] a, int lo, int hi) {
+
+        int i = lo;
+        int j = hi + 1;
+        while(true) {
+            while(i < hi && less(a[++i], a[lo]));
+            while(j > lo && less(a[lo], a[--j]));
+            if(i >= j) {
+                break;
+            }
+            exch(a, i, j);
+        }
+        exch(a, lo, j);
+        return j;
+    }
+
+    private void exch(int[] a, int i, int j) {
+        final int tmp = a[i];
+        a[i] = a[j];
+        a[j] = tmp;
+    }
+
+    private boolean less(int v, int w) {
+        return v < w;
+    }
+
+    private void shuffle(int a[]) {
+        final Random random = new Random();
+        for(int ind = 1; ind < a.length; ind++) {
+            final int r = random.nextInt(ind + 1);
+            exch(a, ind, r);
+        }
+    }
+}
diff --git a/python/215_Kth_Largest_Element_in_an_Array.py b/python/215_Kth_Largest_Element_in_an_Array.py
@@ -0,0 +1,40 @@
+class Solution(object):
+    # def findKthLargest(self, nums, k):
+    #     """
+    #     :type nums: List[int]
+    #     :type k: int
+    #     :rtype: int
+    #     """
+    #     return sorted(nums, reverse=True)[k - 1]
+
+    # def findKthLargest(self, nums, k):
+    #     # build min heap
+    #     heapq.heapify(nums)
+    #     # remove n - k smallest number
+    #     while len(nums) > k:
+    #         heapq.heappop(nums)
+    #     return nums[0]
+    #     #return heapq.nlargest(k, nums)[-1]
+
+    def findKthLargest(self, nums, k):
+        # shuffle nums to avoid n*n
+        random.shuffle(nums)
+        return self.quickSelection(nums, 0, len(nums) - 1, len(nums) - k)
+
+    def quickSelection(self, nums, start, end, k):
+        if start > end:
+            return float('inf')
+        pivot = nums[end]
+        left = start
+        for i in range(start, end):
+            if nums[i] <= pivot:
+                # swip left and i
+                nums[left], nums[i] = nums[i], nums[left]
+                left += 1
+        nums[left], nums[end] = nums[end], nums[left]
+        if left == k:
+            return nums[left]
+        elif left < k:
+            return self.quickSelection(nums, left + 1, end, k)
+        else:
+            return self.quickSelection(nums, start, left - 1, k)
diff --git a/python/347_Top_K_Frequent_Elements.py b/python/347_Top_K_Frequent_Elements.py
@@ -7,4 +7,4 @@ def topKFrequent(self, nums, k):
         """
         counter = collections.Counter(nums)
         return [k for k,v in counter.most_common(k)]
-        # return heapq.nlargest(k, count.keys(), key=count.get) 
+        # return heapq.nlargest(k, count.keys(), key=count.get)
