如何理解“堆”?
什么是堆?
堆是一种特殊的树。必须满足下面两点,才叫做堆
- 堆是一个完全二叉树:
- 完全二叉树要求,除了最后一层,其他层的节点个数都是满的,最后一层的节点都靠左排列。
- 堆中每一个节点的值都必须大于等于(或小于等于)其子树中每个节点的值。
- 对于每个节点的值都大于等于子树中每个节点值的堆,我们叫作大根堆
- 对于每个节点的值都小于等于子树中每个节点值的堆,我们叫作小根堆。
- (也就是说,一棵树,要么是大根堆,要么是小根堆。不可能是其他)
下面我们来看看大根堆、小根堆具体的图是怎么画的:
我们对上面的图中每个数都进行了标记,上面的结构映射成数组就变成了下面这个样子
从上面可以看出:
如果当前节点的下标是 i ,那么 如果当前节点的下标是i,那么 如果当前节点的下标是i,那么
- 父结点索引: i − 1 2 父结点索引:\frac{i-1}{2} 父结点索引:2i−1(这里计算机中的除以2,省略掉小数)
- 左孩子索引: 2 ∗ i + 1 左孩子索引:2*i+1 左孩子索引:2∗i+1
- 右孩子索引: 2 ∗ i + 2 右孩子索引:2*i+2 右孩子索引:2∗i+2
所以上面两个数组可以脑补成堆结构,因为他们满足堆的定义性质:
- 大根堆: a r r ( i ) > a r r ( 2 ∗ i + 1 ) arr(i)>arr(2*i+1) arr(i)>arr(2∗i+1) && a r r ( i ) > a r r ( 2 ∗ i + 2 ) arr(i)>arr(2*i+2) arr(i)>arr(2∗i+2)
- 小根堆: a r r ( i ) < a r r ( 2 ∗ i + 1 ) arr(i)<arr(2*i+1) arr(i)<arr(2∗i+1) && a r r ( i ) < a r r ( 2 ∗ i + 2 ) arr(i)<arr(2*i+2) arr(i)<arr(2∗i+2)
大根堆和小根堆都是从当前节点的视角出发,往下看,看它和它的孩子们的关系
最后一个非叶子节点的序号是 n / 2 − 1 n/2-1 n/2−1的推理
可以分两种情形考虑:
- 堆的最后一个非叶子节点只有左子节点
- 堆的最后一个非叶子节点有左右两个子节点
堆的定义:
- 大顶堆: a r r [ i ] > = a r r [ 2 i + 1 ] arr[i] >= arr[2i+1] arr[i]>=arr[2i+1] && a r r [ i ] > = a r r [ 2 i + 2 ] arr[i] >= arr[2i+2] arr[i]>=arr[2i+2]
- 小顶堆: a r r [ i ] < = a r r [ 2 i + 1 ] arr[i] <= arr[2i+1] arr[i]<=arr[2i+1] && a r r [ i ] < = a r r [ 2 i + 2 ] arr[i] <= arr[2i+2] arr[i]<=arr[2i+2]
完全二叉树的性质之一是:
- 如果节点序号为
i
i
i,则其:
- 左子节点序号为 2 i + 1 2i+1 2i+1,
- 右子节点序号为 2 i + 2 2i+2 2i+2。
- 对于第一种情形:
- 左子节点的序号为 n − 1 n-1 n−1,则 n − 1 = 2 ∗ i + 1 n-1=2*i+1 n−1=2∗i+1,推出 i = n / 2 − 1 i=n/2-1 i=n/2−1;
- 对于第二种情形:
- 左子节点的序号为 n − 2 n-2 n−2,在 n − 2 = 2 i + 1 n-2=2i+1 n−2=2i+1,推出 i = ( n − 1 ) / 2 − 1 i=(n-1)/2-1 i=(n−1)/2−1;
- 右子节点的序号为 n − 1 n-1 n−1,则 n − 1 = 2 i + 2 n-1=2i+2 n−1=2i+2,推出 i = ( n − 1 ) / 2 − 1 i=(n-1)/2-1 i=(n−1)/2−1;
很显然:
- 当完全二叉树最后一个节点是其父节点的左子节点时,树的节点数为偶数;
- 当完全二叉树最后一个节点是其父节点的右子节点时,树的节点数为奇数。
- 根据语法的特征,/ 符号取整,则若n为奇数时 ( n − 1 ) / 2 − 1 = n / 2 − 1 (n-1)/2-1=n/2-1 (n−1)/2−1=n/2−1。
如何实现一个堆
要实现一个堆,我们先要知道,堆都支持哪些操作以及如何存储一个堆。
我们知道,完全二叉树比较适合用数组来存储。用数组来存储完全二叉树是非常节省内存的。因为我们不需要存储左右子节点的指针,单纯的通过数组的下标,就可以找到一个节点的左右子节点和父节点
(为了方便,下面我们都是假设堆中的数据是从数组下标为1的位置开始存储。如果从0开始存储,实际上处理思路是一样的,不一样的是计算父子节点的下标公式。)
从上图可以看到,数组中下标为i的节点的左子节点就是下标为
i
∗
2
i*2
i∗2的节点,右子节点就是下标为
i
∗
2
+
1
i*2+1
i∗2+1的节点,父节点就是下标为
i
2
{\frac{i}{2}}
2i的节点。
知道了如何存储一个堆,那我们再来看看,堆上的操作有哪些呢?下面以大根堆为例
往堆中插入一个元素
往堆中插入一个元素后,我们需要继续满足堆的两个特性。
如果我们把新插入的元素放在堆的最后,如下图,就不符合堆的特性了。
这个时候,我们就需要进行调整,让其重新满足堆的特性。这个过程叫做堆化(heapify)。
堆化实际上有两种,从下往上和从上往下。先来看下从小往上。
堆化非常简单,就是顺序节点所在的路径,向上或者向下,对比,然后交换。
如下图:我们可以让新插入的节点与父节点对比大小。如果不满足子节点小于等于父节点的大小关系,我们就互换两个节点。一种重复这个过程,直到父子节点之间满足大小关系
class Heap{
private:
std::vector<int> a; //数组,从下标1开始存储数据
int n; //堆可以存储的最大数据个数
int cnt; //堆中已经存储的数据个数
public:
explicit Heap(int capacity){
a = std::vector<int> (capacity + 1);
n = capacity;
cnt = 0;
}
void insert(int data){
if(cnt >= n){
return;
}
++cnt; //堆中已经存储的数据个数
a[cnt] = data;
int i = cnt;
while (i / 2 >= 0 && a[i] > a[i / 2]){
std::swap(a[i], a[i / 2]);
i = i / 2;
}
}
};
删除堆顶元素
从堆的定义的第二条中,任何节点的值都>=(或者 < = <= <=)子树节点的值,我们可以发现,堆顶元素存储的就是堆中数据的最大值或者最小值。
假设我们构造的是大顶堆,堆顶元素就是最大的元素。当我们删除堆顶元素之后,就需要把第二大的元素放在堆顶,那第二大元素肯定会出现在左右子节点中。然后我们在迭代的删除第二大节点,以此类推,直到叶子节点被删除。
如下图,不能直接从上面删除,否则会出现空洞
我们稍微改变一下思路,如下图。我们把最后一个节点放到堆顶,然后利用同样的父子节点对比方法。对于不满足父子节点大小关系的,互换两个节点,并且重复进行这个过程,直到父子节点之间满足大小关系为止。这就是从上往下的堆化方法
我们我们移除的是数组的最后一个元素,而在堆化的过程中,都是交换操作,不会出现数组的”空洞“,所以这种方法堆化之后的结果,肯定满足完全二叉树的特性。
void heapify( std::vector<int> &a, int n, int i){ //自上往下堆化
while (true){
int maxPox = i;
if(i * 2 <= n && a[maxPox] < a[i*2]){
maxPox = i * 2;
}
if(i * 2 + 1 <= n && a[maxPox] < a[i * 2 + 1]){
maxPox = i * 2 + 1;
}
if(maxPox == i){
break;
}
std::swap(a[i], maxPox);
i = maxPox;
}
}
public:
void removeMax(){
if(count == 0){
return; //堆中没有数据
}
a[1] = a[count];
--count;
heapify(a, count, 1);
}
我们知道,一个包含 n n n个节点的完全二叉树,树的高度不会超过 l o g 2 n log_2n log2n。堆化的过程是顺着节点所在路径比较交换的,所以堆化的时间复杂度跟树的高度成正比,也就是 O ( l o g n ) O(logn) O(logn)。插入数据和删除堆顶元素的主要逻辑就是堆化,所以,往堆中插入一个元素和删除堆顶元素的时间复杂度都是 O ( l o g n ) O(logn) O(logn)
应用
如何基于堆实现排序
堆是一种特殊的树,而堆排序是根据堆的这种数据结构设计的一种排序。这种排序方法的时间复杂度非常稳定,是 O ( l o g n ) O(logn) O(logn) ,并且它还是原地排序算法。如此优秀,它是怎么做到的呢?
我们可以把堆排序的过程大致分为两个步骤,建堆和排序
建堆
我们首先将数组原地建立成一个堆。所谓”原地“就是,不借助另一个数组,就在原数组上操作。建堆的过程,有两种思路
(1)第一种就是借助上面讲的,在堆中插入一个元素的思路。尽管数组中包含n个数据,但是我们可以假设,起初堆中只包含一个数据,就是下标为1的数据。然后,我们调用前面讲的插入操作,将下标从2到n的数据依次插入到堆中。这样我们就将包含n个数据的数组,组织成了堆
(2)第二种实现思路跟第一种相反。第一种建堆思路的处理过程是从前往后处理数组数据,并且每个数据插入到堆中时,都是从下往上堆化。而第二种实现思路,是从后往前处理数据,并且每个数据都是从上往下堆化。
举个例子,如下,因为叶子节点往下堆化只能自己跟自己比较,所以我们直接从第一个非叶子节点开始,依次堆化就行了。
void buildHeap(std::vector<int> &a, int n){
for (int i = n/2; i >= 1; --i){
heapify(a, n, i);
}
}
从上面可以看出,我们堆下标从 n 2 \frac{n}{2} 2n开始到1的数据进行堆化,下标是 n 2 + 1 \frac{n}{2}+1 2n+1到 n n n的节点是叶子节点,我们不需要堆化。实际上,对于完全二叉树来说,下标从 n 2 + 1 \frac{n}{2}+1 2n+1到 n n n的节点都是叶子节点。(堆是完全二叉树,求最后的非叶子节点即是求最大的叶子节点的父节点。最大的叶子节点下标为n,他的父节点为n/2,这是最后一个非叶子节点,所以n/2+1到n都是叶子节点。)
现在,我们来看,建堆操作的时间复杂度是多少呢?
每个节点堆化的时间复杂度是 O ( l o g n ) O(logn) O(logn),那 n 2 + 1 \frac{n}{2}+1 2n+1g个节点堆化的总时间复杂度是不是就是 O ( n l o g n ) O(nlogn) O(nlogn)。这个答案虽然也没有错,但是还是不够精确。实际上,堆排序建堆过程的时间复杂度是O(n),推导过程如下:
-
因为叶子节点不需要堆化,所以需要堆化的节点从倒数第二层开始。每个节点堆化的过程中,需要比较和交换的节点个数,跟这个节点的高度k成正比
-
每一层的节点个数和对应的高度如下图,我们只需要将每个节点的高度求和,得出的就是建堆的时间复杂度。
-
我们将每个非叶子节点的高度求和,就是下面这个公式:
-
这个公式的求解稍微有点技巧,不过我们高中应该都学过:把公式左右都乘以2,就得到另一个公式 S 2 S2 S2。我们将 S 2 S2 S2错位对齐,并且用 S 2 S2 S2减去 S 1 S1 S1,可以得到 S S S
-
S的中间部分是一个等比数列,所以最后可以用等比数列的求和公式来计算
-
因为 h = l o g 2 n h=log_2n h=log2n,带入公式S,就可以得到 S = O ( n ) S=O(n) S=O(n)
所以,建堆的复杂度就是 S = O ( n ) S=O(n) S=O(n)
排序
建堆结束之后,数组中的数据已经是按照大顶堆的特性来组织的。数组中的第一个元素就是堆顶,也就是最大的元素。我们把它跟最后一个元素交换,那最大元素就放到了下标为n的位置。
这个过程有点类似“删除堆顶元素”的操作,当堆顶元素移除之后,我们把下标为n的元素放到堆顶,让后在通过堆化的方法,将剩下的n-1个元素重新构建成堆。堆化完成之后,我们再取堆顶元素,放到下标是n-1的位置,一直重复这个过程,直到最后堆中只剩下下标为1的一个元素,排序工作就完成了
// n 表示数据的个数,数组 a 中的数据从下标 1 到 n 的位置。
static void sort(std::vector<int> &a, int n){
buildHeap(a, n);
int k = n;
while (k > 1){
swap(a, 1, k);
k--;
heapify(a, k, 1);
}
}
现在,我们再来分析一下堆排序的时间复杂度、空间复杂度以及稳定性。
- 整个堆排序的过程中,都需要极个别临时存储空间,所以堆排序是原地排序算法,堆排序包括建堆和排序两个操作,建堆过程的时间复杂度是O(n),排序过程的时间复杂度是O(nlogn),所以堆排序整体的时间复杂度是O(nlogn)
- 堆排序不是稳定的算法,因为在排序的过程,存在将堆的最后一个节点跟堆顶节点互换的操作,所以就有可能改变相同数据的原始相对顺序。
如果以0为起始索引,那么实现
代码中主要两个方法:
1、将待排序数组构造成一个大根堆(元素上升)
2、固定一个最大值,将剩余的数再构造成一个大根堆(元素下降)
java版本:
//堆排序
public static void heapSort(int[] arr) {
//构造大根堆
heapInsert(arr);
int size = arr.length;
while (size > 1) {
//固定最大值
swap(arr, 0, size - 1);
size--;
//构造大根堆
heapify(arr, 0, size);
}
}
//构造大根堆(通过新插入的数上升)
public static void heapInsert(int[] arr) {
for (int i = 0; i < arr.length; i++) {
//当前插入的索引
int currentIndex = i;
//父结点索引
int fatherIndex = (currentIndex - 1) / 2;
//如果当前插入的值大于其父结点的值,则交换值,并且将索引指向父结点
//然后继续和上面的父结点值比较,直到不大于父结点,则退出循环
while (arr[currentIndex] > arr[fatherIndex]) {
//交换当前结点与父结点的值
swap(arr, currentIndex, fatherIndex);
//将当前索引指向父索引
currentIndex = fatherIndex;
//重新计算当前索引的父索引
fatherIndex = (currentIndex - 1) / 2;
}
}
}
//将剩余的数构造成大根堆(通过顶端的数下降)
public static void heapify(int[] arr, int index, int size) {
int left = 2 * index + 1;
int right = 2 * index + 2;
while (left < size) {
int largestIndex;
//判断孩子中较大的值的索引(要确保右孩子在size范围之内)
if (arr[left] < arr[right] && right < size) {
largestIndex = right;
} else {
largestIndex = left;
}
//比较父结点的值与孩子中较大的值,并确定最大值的索引
if (arr[index] > arr[largestIndex]) {
largestIndex = index;
}
//如果父结点索引是最大值的索引,那已经是大根堆了,则退出循环
if (index == largestIndex) {
break;
}
//父结点不是最大值,与孩子中较大的值交换
swap(arr, largestIndex, index);
//将索引指向孩子中较大的值的索引
index = largestIndex;
//重新计算交换之后的孩子的索引
left = 2 * index + 1;
right = 2 * index + 2;
}
}
//交换数组中两个元素的值
public static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
golang版本:
package main
import (
"fmt"
)
// 最大堆登顶
func HeapFindMax(arr[]int, size int) {
if size <= 1{
return
}else{
noLeaf := size / 2 - 1 // 最后一个非叶子节点索引
for i := noLeaf ; i >= 0; i-- { // 最后一个非叶子节点索引为0
left := 2 * i + 1 // 左孩子索引
right := 2 * i + 2 // 右孩子索引
max := i //假定当前索引为最大值
if left < size && arr[left] > arr[max] { // 避免溢出
max = left
}
if right < size && arr[right] > arr[max] {
max = right
}
if max != i { // 最大登顶
arr[max], arr[i] = arr[i], arr[max]
}
}
}
}
func HeapSort(arr []int) {
size := len(arr)
if size <= 1{
return
}else{
for i := 0; i < size ; i++ {
cut := size - i // 每次截取一个
HeapFindMax(arr, cut)
if cut - 1 > 0 {
arr[0], arr[cut - 1] = arr[cut - 1], arr[0]
}
}
}
}
func main() {
arr:=[]int {9, 1, 3, 6, 5, 4, 2, 7, 8}
HeapSort(arr)
fmt.Println(arr)
}
堆排序的时间复杂度O(N*logN),额外空间复杂度O(1),是一个不稳定性的、原地的排序
优先级队列
优先级队列,顾名思义,它首先应该是一个队列。队列最大的特性就是先进先出。不过,在优先级队列中,数据的出对顺序不是先进先出,而是按照优先级来,优先级最高的,最先出队。
如何实现一个优先级队列呢?方法有很大,但是用堆来实现是最直接最高效的。这是因为,堆和优先级队列非常相似。一个堆就可以看出是一个优先级队列。很多时候,它们只是概念上的区分而已。往优先级队列中插入一个元素,就相当于往堆中插入一个元素;从优先级队列中取出优先级最高的元素,就相当于取出堆顶元素。
优先级队列应用非常广泛,比如赫夫曼编码、图的最短路径、最小生成树算法等等。举两个例子
合并有序小文件
假设我们有100个小文件,每个文件的大小是100MB,每个文件中存储的都是有序的字符串。我们希望将这100个小文件合并成一个有序的大文件。这里就会用到优先级队列:
- 整体思路有点像归并排序中的合并函数。我们从这100个文件中,各取第一个字符串,放入数组中,然后比较大小,把最小的哪个字符串放入合并后的大文件中,并从数组中删除。
- 假设,这个最小字符串来自于13.txt这个小文件,我们就再从这个小文件取下一个字符串,并且放到数组中,重新比较大小,并且选择最小的放入合并后的大文件,并且将它从数组中删除。依次类推,直到所有的文件中的数据都放入到大文件为止。
这里我们用数组这种数据结构,来存储从小文件中取出来的字符串。每次从数组中取最小字符串,都需要循环遍历整个数组,显然,这不是很高效。有没有更加高效的方法呢?
- 这里可以用优先级队列,也就是堆。
- 我们将从小文件中取出来的字符串放入到小顶堆中,那堆顶的元素,也就是优先级队列队首的元素,就是最小的字符串。 我们将这个字符串放入到大文件中,并将其从堆中删除
- 然后再从小文件中取出下一个字符串,放入堆中。
- 循环这个过程,就可以将100个小文件中的数据依次放入到大文件中
,删除堆顶数据和往堆中插入数据的时间复杂度都是 O(logn),n 表示堆中的数据个数,这里就是 100。
高性能定时器
假设我们有一个定时器,定时器中维护了很多定时任务,每个任务都设定了一个要触发执行的时间点。定时器每过一个很小的单位时间(比如1s),就扫描一遍任务,看是否有任务到达设定的时间点。如果到达了,就拿出来执行。
但是,这样每过1秒就扫描一遍任务列表的做法比较低效,主要原因有两点:
- 第一,任务的约定执行时间离当前时间可能还有很久,这样前面很多次扫描其实都是徒劳的
- 第二,每次都要扫描整个任务列表,如果任务列表很大的化,势必会比较耗时
针对这些问题,我们可以用优先级队列来解决
- 我们按照任务设定的执行时间,将这些任务存储在优先级队列中,队列首部(也就是小顶堆的堆顶)存储的是最先执行的任务
- 这样,定时器就不需要每隔1s就扫描一遍任务列表了。它拿队首任务的执行时间点,与当前时间点相减,得到一个时间间隔T
- 这个时间间隔T就是,从当前时间开始,需要等待多久,才会有第一个任务需要被执行。这样,定时器就可以设定在T秒之后,再来执行任务。从当前时间点到(T-1)秒这段时间里,定时器都不需要做任何事情
- 当T秒时间过去之后,定时器取优先级队列中队首的任务执行。然后再计算新的队首任务的执行时间点与当前时间点的差值,把这个值作为定时器执行下一个任务需要等待的时间
利用堆求Top K
这种求 Top K 的问题可以抽象成两类:
- 一类是针对静态数据集合,也就是说数据集合事先确定,不会再变
- 一类是针对动态数据集合,也就是说数据集合事先不确定,有数据动态的加入到集合中
针对静态数据,如何再一个包含n个数据的数组中,查找前k大的数据呢?
- 我们可以维护一个大小为K的小顶堆,顺序遍历数组,从数组总取数据与堆顶元素比较。如果比堆顶元素大,我们就把堆顶元素删除,并且将这个元素插入到集合中
- 如果比堆顶元素小,则不做处理,继续遍历数组
- 这样等数组中的数据都遍历完之后,堆中的数据就是前K大数据了
遍历数组需要O(n)的时间复杂度,一次堆化操作需要O(logK)的时间复杂度,所以最坏情况下,n个元素都入堆一次,所以时间复杂度是 O ( n l o g K ) O(nlogK) O(nlogK)。
针对动态数据求的TopK就是实时Top K。怎么理解呢?举个例子,一个数据集合中有两个操作,一个是添加操作,一个是询问当前的前K大数据
- 如果每次询问前K大数据,我们都基于当前的数据重新计算的话,那时间复杂度就是 O ( n l o g K ) O(nlogK) O(nlogK),n表示当前数据大小
- 实际上,我们可以一直都维护一个K大小的小顶堆,当有数据添加时,我们就拿它和堆顶元素对比。
- 如果比堆顶元素大,我们就把堆顶元素删除,并将这个元素插入到堆中
- 如果比堆顶元素小,则不做处理
- 这样,无论任何时候需要查询当前的前K大元素,我们都可以立刻返回给它
利用堆求中位数
中位数,顾名思义,就是处在中间位置的那个数。
- 如果数据的个数是奇数的话,把数据从小到大排列,那第 n 2 + 1 \frac{n}{2}+1 2n+1个数据就是中位数
- 如果数据的个数是偶数的话,那处于中间位置的数据有两个,第 n 2 \frac{n}{2} 2n和第 n 2 + 1 \frac{n}{2}+1 2n+1个数据,这个时候,我们可以随意取一个作为中位数,比如取两个数中靠前的那个,就是第 n 2 \frac{n}{2} 2n个数据。
对于一组静态数据,中位数是固定的,我们可以先排序,第 n 2 \frac{n}{2} 2n个数据就是中位数。每次询问中位数的时候,我们直接返回这个固定的值就号了。所以,尽管排序的代价会比较大,但是边际成本会很小。但是,如果我们面对的是动态数据集合,中位数在不停的变动,如果在利用先排序的方法,每次询问中位数的时候,都要先进行排序,那效率就不高了。
这时我们可以借助堆这种数据结构,不用排序就可以非常高效的求中位数操作:
- 我们需要维护两个堆,一个大顶堆,一个小顶堆。大顶堆中存储前半部分数据,小顶堆存储后半部分数据,而且小顶堆中的数据都大于大顶堆中的数据
- 也就是说,如果有n个数据,n是偶数,我们从小到大排序,那前 n 2 \frac{n}{2} 2n个数据存储在大顶堆中,后 n 2 \frac{n}{2} 2n个数据存储在小顶堆中。 这样,大顶堆中的堆顶元素就是我们要找的中位数。
- 如果n是奇数,大顶堆就存储 n 2 + 1 \frac{n}{2}+1 2n+1个数据,小顶堆就存储 n 2 \frac{n}{2} 2n个数据。这样,大顶堆中的堆顶元素就是我们要找的中位数。
数据是动态变化的,当新添加一个数据的时候,我们如何调整两个堆,让大顶堆中的堆顶元素继续是中位数呢?
- 如果新加入的数据<=大顶堆中的堆顶元素,我们就将这个新数据插入到大顶堆
- 如果新加入的数据>=小顶堆中的堆顶元素,我们就将这个新数据插入到小顶堆(????)
这时就有可能出现,两个堆中的数据个数不符合前面约定: 如果n是偶数,两个堆中数据个数都是 n 2 \frac{n}{2} 2n ;如果n是奇数,大顶堆有 n 2 + 1 \frac{n}{2}+1 2n+1个数据,小顶堆有 n 2 \frac{n}{2} 2n个数据
这个时候,我们可以从一个堆中不停的将堆顶元素移动到另一个堆,通过这样的调整,来让两个堆中的数据满足上面的约定。
于是,我们就可以利用两个堆,一个大顶堆、一个小顶堆,实现在动态数据集合中求中位数的操作。插入数据因为需要涉及堆化,所以时间复杂度变成了 O(logn),但是求中位数我们只需要返回大顶堆的堆顶元素就可以了,所以时间复杂度就是 O(1)。
利用堆求99% 响应时间
实际上,利用两个堆不仅可以快速求出中位数,还可以快速求其他百分位的数据。举个例子,应用中常见的需求是”如何快速求接口的99%响应时间“。
那什么是”99%响应时间“
- 中位数的概念就是将数据从小到大排列,处于中间位置,就叫做中位数,这个数据会大于等于前面50%的数据。 99百分位数的概念可以类比中位数,如果将一组数据从小到大排列,这个99百分位数就是大于前面99%数据的那个数据。
- 举个例子:假设有 100 个数据,分别是 1,2,3,……,100,那 99 百分位数就是 99,因为小于等于 99 的数占总个数的 99%。
- 弄懂了这个概念,我们再来看 99% 响应时间。如果有 100 个接口访问请求,每个接口请求的响应时间都不同,比如 55 毫秒、100 毫秒、23 毫秒等,我们把这 100 个接口的响应时间按照从小到大排列,排在第 99 的那个数据就是 99% 响应时间,也叫 99 百分位响应时间。
总结:如果有 n 个数据,将数据从小到大排列之后,99 百分位数大约就是第n99% 个数据,同类,80 百分位数大约就是第 n80% 个数据。
如何求99%的响应时间。
+我们维护两个堆,一个大顶堆,一个小顶堆。假设当前总数据的个数是 n,大顶堆中保存n99% 个数据,小顶堆中保存 n1% 个数据。大顶堆堆顶的数据就是我们要找的 99% 响应时间。
- 每次插入一个数据的时候,我们要判断这个数据跟大顶堆和小顶堆堆顶数据的大小关系,然后决定插入到哪个堆中。如果这个新插入的数据比大顶堆的堆顶数据小,那就插入大顶堆;如果这个新插入的数据比小顶堆的堆顶数据大,那就插入小顶堆。
- 为了保持大顶堆中的数据占 99%,小顶堆中的数据占 1%,在每次新插入数据之后,我们都要重新计算,这个时候大顶堆和小顶堆中的数据个数,是否还符合 99:1 这个比例。如果不符合,我们就将一个堆中的数据移动到另一个堆,直到满足这个比例。
通过这样的方法,每次插入数据,可能会涉及几个数据的堆化操作,所以时间复杂度是O(logn)。每次求 99% 响应时间的时候,直接返回大顶堆中的堆顶数据即可,时间复杂度是 O(1)。
为什么说堆排序没有快速排序快?
快速排序,平均情况下,它的时间复杂度也为 O ( n l o g n ) O(nlogn) O(nlogn)。尽管这两种排序算法的时间复杂度都是 ,甚至堆排序比快速排序的时间复杂度还要稳定,但是在实际的软件开发中,快速排序的性能要比堆排序好,这是为什么呢?
原因如下:
(1)堆排序数据访问的方式没有快速排序友好
对于快速排序来说,数据是顺序访问的。而堆排序来说,数据是跳着访问的。比如,堆排序中,最重要的一个操作就是数据的堆化。比如下图,对堆顶节点进行堆化,会依次访问数组下标是1、2、4、8的元素,而不是像快速排序那样,局部顺序访问,所以,这样对CPU缓存不友好。
(2)对于同样的数据,在排序过程中,堆排序算法的数据交换多于快速排序
排序中有两个概念,有序度和逆序度。对于基于比较的排序算法来说,整个排序过程就是由两个基本的操作组成的,比较和交换(或移动)。快速排序数据交换的次数不会比逆序度多。
但是堆排序的第一步就是建堆,建堆的过程会打乱原有的相对先后顺序,导致原数据的有序度降低。比如,对于一组已经有序的数据来说,经过建堆之后,数据反而变得更无序了。
小结
堆是一种完全二叉树。它最大的特性是:每个节点的值都大于等于(或小于等于)其子树节点的值。因此,堆被分成了两类,大顶堆和小顶堆。
堆中比较重要的两个操作时插入一个数据和删除堆顶元素。这两个操作都要用到堆化。插入一个数据的时候,我们把新插入的数据放到数组的最后,然后从下往上堆化;删除堆顶元素的时候,我们把数组中的最后一个元素放到堆顶,然后从上往下堆化。这两个操作时间复杂度但是 O ( l o g n ) O(logn) O(logn)
堆的一个比较经典的应用时堆排序。堆排序包含两个过程,建堆和排序。我们将下标从 n 2 \frac{n}{2} 2n到1的节点,依次进行从上到下的堆化操作,然后就可以将数组中的数据组织成这种数据结果。接下来,我们迭代的将堆顶元素放到堆的末尾,并将堆的大小减一,然后在堆化,重复这个过程,直到堆中只剩下一个元素,整个数组中的数据就有序排列了。
优先级队列是一种特殊的队列,优先级高的数据先出队,而不再像普通的队列那样,先进先出。实际上,堆就可以看作优先级队列,只是称谓不一样罢了。求 Top K 问题又可以分为针对静态数据和针对动态数据,只需要利用一个堆,就可以做到非常高效率的查询 Top K的数据。求中位数实际上还有很多变形,比如求 99 百分位数据、90 百分位数据等,处理的思路都是一样的,即利用两个堆,一个大顶堆,一个小顶堆,随着数据的动态添加,动态调整两个堆中的数据,最后大顶堆的堆顶元素就是要求的数据。
实现链式堆
有一个需求:有千亿个数据,需要求得最大值,应该怎么做
打: 这当然不能用数组,如果用数组的话,需要先把所有数据读到内存中,然后在比较。内存没有那么大。
也不能一个个从磁盘中读取数据,因为非常耗费磁盘IO。 我们可以使用链式堆来做
golang
package main
import "fmt"
// 假设没有重复的数据,假设需要插入的数据全部是int类型
type LinkedNode struct {
data interface{}
left *LinkedNode
right *LinkedNode
depth int
}
func NewLinkHeap(data interface{}) (*LinkedNode) {
node := new(LinkedNode)
node.left = nil
node.right = nil
node.depth = 0
node.data = data
return node
}
func MergeSort(l *LinkedNode, h *LinkedNode) (*LinkedNode) {
if(l.left == nil){
l.left = h
}else{
l.right = Merge(l.right, h)
if(l.right.depth > l.left.depth){
l.left, l.right = l.right, l.left
}
l.depth = l.right.depth + 1
}
return l
}
func Merge(n *LinkedNode, h *LinkedNode)(*LinkedNode) {
if(n == nil){
return h
}else if(h == nil){
return n
}else{
if(h.data.(int) < n.data.(int)){ //递归排序,>取得极大,<取得极小
return MergeSort(h, n)
}else{
return MergeSort(n, h)
}
}
}
func InsertData(data interface{}, h *LinkedNode)(*LinkedNode) {
newNode := NewLinkHeap(data)
h = Merge(newNode, h)
return h;
}
func printHeap(h *LinkedNode) {
if(h == nil){
return
}
printHeap(h.left)
printHeap(h.right)
fmt.Print(h.data , " , ")
}
func DeleteMin(h *LinkedNode) (*LinkedNode, interface{}) {
if(h == nil){
return nil, nil
}else{
leftTree := h.left
rightTree := h.right
value := h.data
h = nil
return Merge(leftTree, rightTree), value
}
}
func main() {
h := NewLinkHeap(3)
h = InsertData(2, h)
h = InsertData(1, h)
h = InsertData(0, h)
h = InsertData(4, h)
h = InsertData(5, h)
h = InsertData(6, h)
h, data := DeleteMin(h);
fmt.Println("min = ", data)
printHeap(h)
fmt.Println()
h, data = DeleteMin(h);
fmt.Println("min = ", data)
printHeap(h)
}
过程如下:【取得最小值】
1、初始化一个节点,作为原始堆
2、插入2
3、插入1
4、插入0:同上
5、插入4
6、插入5
6、插入6
7、删除当前最小值。
- 如果当前堆为空,直接返回nil
- 否则备份左右子树: leftTree = h.left, rightTree = h.right, h = nil
- 然后合并左右子树merge(leftTree, rightTree)
思考 【目的:构建一个最小堆】
- 为什么 MergeSort函数中只折腾h1[小节点]的左右子节点::
- 因为在Merge函数中我们已经确定了h2的值一定比h1的值大。所以h2一定是h1的子节点,只是不确定是左节点还是右节点。还是哪一层的节点。
- 为什么MergeSort函数中h1的左节点为空,就直接把h2作为当前节点的左节点。
- 因为堆一定是一个完全二叉树。如果当前节点的左节点为空,说明当前堆只有h1一个元素,而h2一定比h1大,所以直接把h2放到h1的左节点
- 完全二叉树的深度 = 右子树的深度 + 1. 因此如果右子树有元素插入,就要重新计算一遍当前子树深度大小。
- 因为堆是完全二叉树,完全二叉树的左子树深度一定比右子树大,因此如果右子树深度大于左子树,那么交换两者位置。