LeetCode 215. Kth Largest Element in an Array（最小堆/快速排序）

Kth Largest Element in an Array

algorithms Medium (47.26%) 1900 160

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.

Example 1:

Input: [3,2,1,5,6,4] and k = 2
Output: 5
Example 2:

Input: [3,2,3,1,2,4,5,5,6] and k = 4
Output: 4
Note:
You may assume k is always valid, 1 ≤ k ≤ array’s length.

题意

找到无序数组中第k大的元素

思路

【方法1】
维护一个大小为k的最小堆，遍历数组，如果数组元素比堆顶元素大，则用该元素替换堆顶元素。时间复杂度为O(nlogk).
【方法2】
用快速排序中分治的思想
取基准元素，将无序数组分为前后两段，前段所有元素的值小于等于基准，后段所有元素的值大于等于基准。记后段的长度为blen, 每次切分时，每次分治时，分3种情况讨论：

• blen = k-1: 此时说明有k-1个数大于等于基准，基准就是第k大大数，直接返回基准
• blen < k-1：此时说明第k大的数在前段，在前段中查找第(k-blen-1)大的数
• blen > k-1：说明此时第k大的数在后段，在后段中查找第k大的数
  此外还要注意类快排的分治法性能不稳定，分治的均匀性会影响算法的时间复杂度，分治越不均匀，算法效率越低。因此，当k=1或k=n时不要分治了，直接O(n)遍历数组求最大/最小值即可。这个优化可以大大提高效率。而最小堆解法性能稳定，不需要对k=1和k=n进行特殊处理。

代码

【java的最小堆解法】

/*
 * @lc app=leetcode id=215 lang=java
 *
 * [215] Kth Largest Element in an Array
 */
class Solution {
    public int findKthLargest(int[] nums, int k) {
        PriorityQueue<Integer> pq = new PriorityQueue<Integer>(k);
        int i = 0;
        for (i=0; i<k; i++)
        {
            pq.add(nums[i]);
        }
        for (int n = nums.length; i<n; i++)
        {
            if (nums[i] > pq.peek())
            {
                pq.poll();
                pq.add(nums[i]);
            }
        }
        return pq.peek();
    }
}

【go的分治解法】

/*
 * @lc app=leetcode id=215 lang=golang
 *
 * [215] Kth Largest Element in an Array
*
*  partition quick sort solution by golang
 */
func findKthLargest(nums []int, k int) int {
	return recurFindK(nums, k, 0, len(nums))
}

func recurFindK(nums []int, k int, left int, right int) int {
    if k == 1 {
        mymax := nums[left]
        for i:=left+1; i<right; i++ {
            if mymax < nums[i] {
                mymax = nums[i]
            }
        }
        return mymax
    } else if k == right - left {
        mymin := nums[left]
        for i:=left+1; i<right; i++ {
            if mymin > nums[i] {
                mymin = nums[i]
            }
        }
        return mymin
    }
	pivot := nums[left]
	i, j := left, right-1
	for i < j {
        for i < j && nums[j] >= pivot {
			j--
		}
        nums[i] = nums[j]
		for i < j && nums[i] <= pivot {
			i++
		}
		nums[j] = nums[i]
	}
    nums[j] = pivot
	if right - j == k {
		return pivot
	} else if right - j < k {
		return recurFindK(nums, k - right + j, left, j)
	} else {
		return recurFindK(nums, k, j+1, right)
	}
}