算法 - 堆排序 - 随时找到数据流的中位数
堆排序
注意，堆这个结构需要知道什么是满二叉树、完全二叉树。堆就是完全二叉树。
堆
使用数组存储数据，用数组模拟二叉堆结构，此时下标的关系有：
- 父结点 i 的左子结点为 2i + 1，右子结点为 2i + 2
- 子结点 i 找父结点公式为：(i - 1) / 2
堆分大根堆和小根堆，每一个结点为子树的最大值称为大根堆，同理可知小根堆。
以大根堆为例学习堆排序算法，小根堆同理做一些转换即可。
heapInsert
构建堆时，heapInsert 是非常重要的构建方法。
建立 i 个数的堆，算法的时间复杂度为
log(!(i-1)) = log1 + log2 + ··· + log(i-1)
数学证明，最终得到建立过程的时间复杂度为 O(N)。
public static void heapInsert(int[] arr, int i) {
//每一次插入新结点，与父结点做比较，调整堆结构
while (arr[i] > arr[(i - 1) / 2]) {
swap(arr, i, (i - 1) / 2);
i = (i - 1) / 2;
}
}
堆的大小 size
堆在内存中可以使用数组实现，数组有数组的长度 length，堆有堆的大小 size，关系为：size <= length。当堆增加一个数时，使用 heapInsert，size++；当堆大小减少时，直接使用 size--，数组中的元素可以保留。
heapify
两个字：下沉！堆排序的核心。
堆中的数据进行修改的时候 heapify 是非常重要的调整方法。调整的时间复杂度为 O(logN)。
当大根堆构建完成后，堆内第 i 个数变小，此时堆结构需要调整。
思路：确保 i 的子结点仍是堆内数据，比较得到两个子结点中的最大值，与 i 结点比较大小。如果 i 结点数大，则堆结构保持不变；否则，将 i 结点与子结点交换位置。循环上述堆结构调整流程。
public static void heapify(int[] arr, int index, int heapSize) {
int left = index * 2 + 1;
while (left < heapSize) {
//比较得到子结点较大值索引
int largest = (left + 1) < heapSize && arr[left] < arr[left + 1]
? left + 1
: left;
//父结点和子结点比较
largest = arr[index] < arr[largest]
? largest
: index;
//数据改变了，但是仍保持大根堆结构
if (largest == index) {
break;
}
swap(arr, index, largest);
//准备下一轮循环的条件
index = largest;
left = index * 2 + 1;
}
}
pop
将堆顶的数弹出，可以用 size - 1 位上的数和堆顶的数交换位置，然后 size--，最后进行 heapify 操作。
问题一：随时找到数据流的中位数
有一个源源不断地吐出整数的数据流，要求做到可以随时取得之前吐出所有数的中位数。这时可以使用两个堆：一个大根堆和一个小根堆存放数据，大根堆最大值小于小根堆的最小值。
思路：
//处理数据流
假设大根堆堆顶为 big，小根堆堆顶为 small
获取第一个数，先进大根堆，这一步不硬性规定的
获取第二个数，比较
if (num <= big) 进大根堆
else 进小根堆
在处理了数据后，根据 Math.abs(big_size - small_size) < 2 的条件决定是否调整堆结构
if true 不调整
else
if big_size 大，则大根堆执行 pop 操作，小根堆执行 heapInsert 操作
else 小根堆执行 pop 操作，大根堆执行 heapInsert 操作
//计算中位数
if big_size = small_size return (big + small) / 2
else
if big_size > small_size return big
else return small
public class _295_FindMedianfromDataStream {
PriorityQueue<Integer> small_heap;
PriorityQueue<Integer> big_heap;
/** initialize your data structure here. */
public _295_FindMedianfromDataStream() {
small_heap = new PriorityQueue<>();
big_heap = new PriorityQueue<>((a, b) -> b - a);
}
// version 1.0
/*public void addNum(int num) {
if (big_heap.isEmpty() && small_heap.isEmpty()) {
big_heap.offer(num);
return;
}
if (big_heap.size() == 1 && small_heap.isEmpty()) {
if (big_heap.peek() > num) {
small_heap.offer(big_heap.poll());
big_heap.offer(num);
} else {
small_heap.offer(num);
}
return;
}
//当堆为空时，num 和 堆内元素比较会出现空指针错误
if (small_heap.size() == big_heap.size()) {
if (num < big_heap.peek()) {
big_heap.offer(num);
} else {
small_heap.offer(num);
}
} else if (small_heap.size() < big_heap.size()) {
if (num > big_heap.peek()) {
small_heap.offer(num);
} else {
small_heap.offer(big_heap.peek());
big_heap.poll();
big_heap.offer(num);
}
} else {
if (num < small_heap.peek()) {
big_heap.offer(num);
} else {
big_heap.offer(small_heap.peek());
small_heap.poll();
small_heap.offer(num);
}
}
}
*/
// version 2.0
public void addNum(int num) {
if (big_heap.isEmpty() && small_heap.isEmpty()) {
big_heap.offer(num);
return;
}
if (num <= big_heap.peek()) {
big_heap.offer(num);
} else {
small_heap.offer(num);
}
if (Math.abs(big_heap.size() - small_heap.size()) > 1) {
if (big_heap.size() > small_heap.size()) {
small_heap.offer(big_heap.poll());
} else {
big_heap.offer(small_heap.poll());
}
}
}
public double findMedian() {
double res;
if (small_heap.size() == big_heap.size()) {
res = (small_heap.peek() + big_heap.peek()) / 2.0;
} else if (small_heap.size() > big_heap.size()) {
res = small_heap.peek();
} else {
res = big_heap.peek();
}
return res;
}
}
上面是我做 LeetCode_295 题的代码，原理是相近的。此前做的时候绕了一些弯路，得到 version 1.0 版。
代码中使用了 Java 的优先级队列 ProrityQueue，在创建大根堆过程中使用了比较器。其实优先级队列就是堆的一种实现，不需要自己实现 heapInsert 和 heapify。
注意：PriorityQueue 的一些方法异同点
| 作用 | 抛出异常 | 返回值 |
|---|---|---|
| 插入 | add(e) | offer(e) |
| 删除 | remove() | poll() |
| 查看 | element() | peek() |
堆排序
三步：
- 堆顶和堆尾部交换位置
- 堆的大小减 1
- heapify 调整
大根堆完成从小到大的排序，小根堆完成从大到小的排序。
public static void heapSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int i = 0; i < arr.length; i++) {
heapInsert(arr, i);
}
int heapSize = arr.length;
while (heapSize != 0) {
swap(arr, 0, heapSize - 1);
heapSize--;
//此处可以简化成一步
//swap(arr, 0, --heapSize);
heapify(arr, 0, heapSize);
}
}
/*和左神代码局部对比*/
//basic
int heapSize = arr.length;
while (heapSize != 0) {
swap(arr, 0, heapSize - 1);
heapSize--;
heapify(arr, 0, heapSize);
}
//advanced
int size = arr.length;
swap(arr, 0, --size);
while (size > 0) {
heapify(arr, 0, size);
swap(arr, 0, --size);
}
从局部代码中可以看到，左神的代码利用了前面判断的 arr.length > 2 的条件，少使用了一次 while 判断 size 的过程。
