[Leetcode] Heap, Divide and conquer--215. Kth Largest Element in an Array

Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.

For example,
Given [3,2,1,5,6,4] and k = 2, return 5.

Solution:

 1st method using quicksort to sort in non-ascending order, and get the kth number. n = len(nums), time complexity is o(nlogn) -

 2nd method. quickselect. set the pivot (e.g. the first element ） and rearrange all the element less than pivot to be in the left, bigger than pivot to be in the right; then compare with the pivot index with k to decide to go next in the left part or right part to recursively do the same thing reference introduction to algorithm texbook or --reference https://en.wikipedia.org/wiki/Selection_algorithm https://discuss.leetcode.com/topic/14611/java-quick-select/2 random algorithm ; Amortized time complexity is o(n), worst case is o(n^2)

 def select(nums, l, r, index):
            if r == l:
                return nums[l]
            #pivot index
            pind = random.randint(l, r)
            nums[l], nums[pind] = nums[pind], nums[l]   #move pivot to the beginning of the
            
            #partition around pivot
            i = l
            for j in xrange(l+1, r+1):
                if nums[j] < nums[l]:
                    i += 1
                    nums[i], nums[j] = nums[j], nums[i]
            nums[i], nums[l] = nums[l],nums[i] 
            
            if index == i:
                return nums[i]
            elif index < i:
                return select(nums, l, i-1, index)
            else:
                return select(nums, i+1, r, index)
            
        index = len(nums) - k
        if nums is None or len(nums) < 1:
            return 0
        return select(nums, 0, len(nums)-1, index)

 3rd method, use heap if built-in heapq is allowed in python,

h = []
        for n in nums:
            heapq.heappush(h, -1*n)     #min-heap
            
        for i in range(0, k-1):
            heapq.heappop(h)
            
        return -1*heapq.heappop(h)

4th - another method that I have not come up with, which is to use multiset, similar to heap ( it is interesting). --reference https://www.liuchuo.net/archives/3016.