LeetCode 215. 数组中的第K个最大元素

215. 数组中的第K个最大元素

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

示例 1:

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5
示例 2:

输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4
说明:

你可以假设 k 总是有效的，且 1 ≤ k ≤ 数组的长度。

方法一:使用堆排序

建立大顶堆，每次建堆完毕，把堆顶元素和数组最后面的数调换位置，如此重复k次。
参考代码：

class Solution:
    def findKthLargest(self, nums: List[int], k: int) -> int:
        def update(i, up, nums):
            j = 2*i+1       #标记左子节点
            while j < up:
                if j+1 < up and nums[j]<nums[j+1]:
                    j += 1
                if nums[i] < nums[j]:
                    nums[i],nums[j] = nums[j],nums[i]
                else:
                    break       #已经调整完毕，提前截止
                i = j
                j = 2*i+1

        def createMaxHeap(low, up, nums):
            for i in range(up//2, -1, -1):
                update(i,up,nums)

        def findkth(nums):
            n = len(nums)
            for i in range(k):
                createMaxHeap(0, n-i, nums)
                nums[0], nums[n-i-1] = nums[n-i-1], nums[0]
            return nums[n-k]

        return findkth(nums)

时间复杂度：O(N·logN)
空间复杂度：O(1)

方法二：基于快速排序的思想

题目要求第k大的数，对应从小到大排序，第n-k+1小的数，因此使用标准快排的划分思想，在传入参数时，转换成求第n-k+1小的数。

class Solution:
    def findKthLargest(self, nums: List[int], k: int) -> int:
        def quickSort(low, high, k, nums):
            if low >= high:
                return nums[low]
            i,j = low,high
            ##枢轴选择中位数
            nums[low], nums[(i+j)//2] = nums[(i+j)//2], nums[low]
            pivot = nums[low]
            while i < j:
                while i < j and nums[j] >= pivot:
                    j -= 1
                nums[i] = nums[j]
                while i < j and nums[i] < pivot:
                    i += 1
                nums[j] = nums[i]
            nums[i] = pivot
            ##判断当前枢轴是否为所求Kth
            if i == k-1:
                return pivot
            elif i > k-1:
                return quickSort(low, i-1, k,nums)
            else:
                return quickSort(i+1, high, k,nums)
        n = len(nums)
        return quickSort(0, n-1, n-k+1, nums)

时间复杂度：O(NlogN)，总体时间复杂度小于NlogN
空间复杂度：O(logN)