【堆】B004_数组中的第 K 个最大元素（PQ / minHeapify / 快速选择）

一、题目描述

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.

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

二、题解

方法一：PQ 维护 k 个元素的最小堆

public int findKthLargest(int[] nums, int k) {
  	PriorityQueue<Integer> pQ = new PriorityQueue<>();
  	for (int n : nums) {
	    pQ.add(n);
	    if (pQ.size() > k)
	      	pQ.poll();
	}
	return pQ.peek();
}

复杂度分析

• 时间复杂度：$O(N\times logk)$，N 为 nums 的元素个数，k 为最小堆中的元素。
• 空间复杂度：$O(k)$，

---

方法二：自建 minHeapify

思路与算法

• 默认使用数组的前k个元素创建一个元素个数为 k 的小顶堆。
• 堆顶的元素是最小的，也当前堆中的 k 个元素的第 k 大元素，当然还有后面的逻辑。
• 遍历剩下的数组元素，只有比堆顶的元素要大，我们才让它替换对顶元素，然后重新调整堆结构。

public int findKthLargest1(int[] nums, int k) {
  //前K个元素原地建小顶堆
  buildHeap(nums, k);
  //遍历剩下的元素，若有元素比堆顶小，则跳过；否则，交换后重新堆化
  for (int i = k; i < nums.length; i++) {
    if (nums[i] > nums[0]) {
      swap(nums, i, 0);
      heapify(nums, k, 0);
    }
  }
  return nums[0];
}

// 从最后一个非叶子结点开始将数组堆化
public void buildHeap(int[] data, int K) {
  for (int i = K/2 - 1; i >= 0; i--)
    heapify(data, K, i);
}

private void heapify(int[] data, int K, int parentIndex) {

  int minIndex = parentIndex;

  while (true) {
    int l = parentIndex * 2 + 1;
    int r = parentIndex * 2 + 2;

    if (l < K && data[l] < data[parentIndex])
      minIndex = l;
    if (r < K && data[r] < data[minIndex])
      minIndex = r;
    //如果minIndex没有发生变化，说明父节点已经是最小了，不用继续调整
    if (minIndex == parentIndex)
      break;

    swap(data, parentIndex, minIndex);
    parentIndex = minIndex;
  }
}

private static void swap (int[] arr, int l, int r) {
  int temp = arr[l];
  arr[l] = arr[r];
  arr[r] = temp;
}

复杂度分析

• 时间复杂度：$O(Nlogk)$，buildHeap 时间复杂度为 $O(k)$；遍历剩下元素并且堆化的时间复杂度为 $(N-k)\times O(logk)$，故总体的时间复杂度为：$O(Nlogk)$。
• 空间复杂度：$O(1)$，

---

方法三：快速选择

快速选择就是每次进行区域划分的时候，选择一个中轴 p（设 x = a[p])，然后进行每一次区域划分后，数组 a 都会呈现这个样子：

• 区间 $[0,q)$ 中的元素 $⩽x$；
• 区间 $[q+1,N)$ 中的元素 $⩾x$
• 因为我无需保证所有元素都是有序的，这样做是比快排要高效地多的。

即：每经过一次这样操作就能缩小排序的范围

class Solution {
    void swap (int[] a, int l, int r) {
        int t = a[l];
        a[l] = a[r];
        a[r] = t;
    }
    int quick_select(int[] a, int l, int r, int k) {
        if (l >= r)
            return a[k];
        int x = a[l + r >>> 1], i = l-1, j = r+1;
        while (i < j) {
            do i++; while (a[i] < x);
            do j--; while (a[j] > x);
            if (i < j) swap(a, i, j);
        }
        if (j >= k) return quick_select(a, l, j, k);
        else        return quick_select(a, j+1, r, k);
    }
    public int findKthLargest(int[] a, int k) {
        int n = a.length;
        return quick_select(a, 0, n-1, n-k);
    }
}

这里 $j$ 是从左往右数，第一个大于等于 $x$ 的数位置，如果 $j⩾k$ 则表示第一个大于等于 $x$ 的数都在 $k$ 的右边，那么我就没有必要再去右边找了

不知道是不是没有卡这个没有加随机化的算法，基本上是 0/1 ms，保险起见还是加上吧…

int quick_select(int[] a, int l, int r, int k) {
    if (l >= r)
        return a[k];
    int p = (int)(Math.random() * (r-l+1)) + l, x = a[p], i = l-1, j = r+1;
    while (i < j) {
        do i++; while (a[i] < x);
        do j--; while (a[j] > x);
        if (i < j) swap(a, i, j);
    }
    if (j >= k) return quick_select(a, l, j, k);
    else        return quick_select(a, j+1, r, k);
}

复杂度分析

• 时间复杂度：$O(N)$
• 空间复杂度：$O(1)$，