regular leetcode

Author: KrisYu

215._kth_largest_element_in_an_array.md

@@ -2,6 +2,8 @@
 
 
 
+<https://leetcode.com/problems/kth-largest-element-in-an-array/>
+
 
 ### 想法
 
@@ -11,12 +13,25 @@
 
 #### O(nlgn)
 
-看这段代码，简直是Pythonize的代表作.
+看这段Swift代码，简直是Pythonize的代表作.
 
 如果需要reverse排序可`reversed = names.sort(>)`
 
 [sort参见](https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Closures.html)
 
+因为nums是不可变，所以其实这样也蛮浪费的，但是可以AC
+
+```swift
+class Solution {
+    func findKthLargest(_ nums: [Int], _ k: Int) -> Int {
+        var sortedNums = nums.sorted()
+        return sortedNums[nums.count - k]
+    }
+}
+```
+
+
+
 
 #### O(n) + O(klgn)
 
@@ -67,10 +82,13 @@ class Solution(object):
 
 
 
+#### O(n) 
+
+发现这个O(n) 是average case， worst case 是 O(n^2)
+
+CLRS ch9.3 可以找到， wikipedia可以找到： https://en.wikipedia.org/wiki/Quickselect
 
-#### O(n)
 
-CLRS ch9.3 可以找到
 
 
 [最佳资源在此处](https://github.com/raywenderlich/swift-algorithm-club/tree/master/Kth%20Largest%20Element)
@@ -81,7 +99,7 @@ CLRS ch9.3 可以找到
 注意写的是第k小的，然后这里是求第k大的
 <https://rosettacode.org/wiki/Quickselect_algorithm#Python>
 
-```
+```python
 class Solution(object):
     def findKthLargest(self, nums, k):
         """
@@ -120,7 +138,54 @@ class Solution(object):
 ```
 
 
-时间复杂度是O(n)，CLRS里面有出现这个算法和证明
+
+对照wikipedia写出来的：
+
+```python
+class Solution(object):
+    def findKthLargest(self, nums, k):
+        """
+        :type nums: List[int]
+        :type k: int
+        :rtype: int
+        """
+        def partition(lst, left, right, pivotIndex):
+            pivotValue = lst[pivotIndex]
+            lst[pivotIndex], lst[right] = lst[right], lst[pivotIndex]
+            storeIndex = left
+            for i in range(left, right):
+                if lst[i] < pivotValue:
+                    lst[storeIndex], lst[i] = lst[i], lst[storeIndex]
+                    storeIndex += 1
+            lst[right], lst[storeIndex] = lst[storeIndex], lst[right]
+            return storeIndex
+
+        # kth smallest
+        def select(lst, left, right, k):
+            if left == right:
+                return lst[left]
+            pivotIndex = left
+            pivotIndex = partition(lst, left, right, pivotIndex)
+
+            if k == pivotIndex:
+                return lst[k]
+            elif k < pivotIndex:
+                return select(lst, left, pivotIndex - 1, k)
+            else:
+                return select(lst, pivotIndex + 1, right, k)
+        n = len(nums)
+        return select(nums, 0, n - 1, n - k)
+```
+
+
+
+跟上面的方法区别也不大，一个recursion， 一个for loop，注意下面跟初等算法解释的对比，因为这里我们并没有去减小lst，所以我们的k是不用变化的。
+
+
+
+
+
+
 
 
 摘自初等算法的解释，我觉得解释的非常棒
@@ -135,7 +200,7 @@ class Solution(object):
 2. 若k <= |A|,则第k小的元素必然在A中,我们可以丢弃子序列B,然后在A中进一步查找;
 3. 若|A| < k,则第k小的元素必然在B中,我们可以丢弃子序列A,然后在B中进一步查找第(k − |A|)小的元素。
 
-注意下划线部分强调了递归的特性。理想情况下,我们总是将序列划分为相 等长度的两个子序列A和B,这样每次都将问题的规模减半,因此性能为线性时 间O(n)。
+注意下划线部分强调了递归的特性。理想情况下,我们总是将序列划分为相 等长度的两个子序列A和B,这样每次都将问题的规模减半,因此性能为线性时间O(n)。
 
 
 关键问题是如何实现划分,将前m小的元素放入一个子序列中,将剩余元素放入另一个中。
@@ -150,4 +215,11 @@ class Solution(object):
 
 4. 若|A| > k − 1,递归在A中寻找第k小的元素;
 
-5. 否则,递归在B中寻找第(k − 1 − |A|)小的元素;
+5. 否则,递归在B中寻找第(k − 1 − |A|)小的元素;
+
+
+
+
+
+
+