二叉堆定义
二叉堆是一种特殊的堆, 二叉堆是完全二叉树或者近似完全二叉树. 二叉堆满足堆特性: 父节点的键值总是保持固定的序关系于任何一个子节点的键值(就是父节点大/小于子节点), 且每个节点的左子树和右子树都是一个二叉堆.
当父节点的键值总是大于或等于任何一个子节点的键值时为最大二叉堆. 当父节点的键值总是小于或等于任何一个子节点的键值时为最小堆
二叉堆的表现形式
二叉堆一般用数组来表示. 如果节点在数组中的位置是n(n是节点在数组中的下标), 则n节点对应的子节点在数组中的位置分别是 2n + 1 和 2n + 2. 因此, 第1个位置的子节点在2和3, 第2个位置的子节点在4和5, 以此类推.
如下图, 左图是最小堆, 右图是最大堆
1 11
/ \ / \
2 3 9 10
/ \ / \ / \ / \
4 5 6 7 5 6 7 8
/\ /\ /\ /\
8 9 10 11 1 2 3 4
而将这两个堆保存在数组中:
左图: 1 2 3 4 5 6 7 8 9 10 11
右图: 11 9 10 5 6 7 8 1 2 3 4
明白了堆的特性以及存储方式, 那我们就能推断出:
1. parent(t) = (t - 1) >>>1 (t指数组中的下标, >>> 或 <<< 表示数据在进行无符号的左右移动, 每移动一位就等于整除2)
2. left(t) = t << 1 + 1
3. right(t) = t << 1 + 2
注意:
parent(t): 指t节点的父节点在数组中的下标
left(t): 指t节点的左子节点在数组中的下标
right(t): 指t节点的右子节点在数组中的下标
基本操作
二叉堆的基本操作: 插入元素, 删除元素, 堆排序, 堆向上调整(siftUp), 堆向下调整(siftDown)
插入元素
/**
* 插入元素到堆中
* @param e
* @return
* @throws InterruptedException
*/
public boolean put(E e) throws InterruptedException{
lock.lockInterruptibly();
try {
if(e == null) throw new NullPointerException();
// 1. 判断堆是否满了, 满了的话就等待, 直到有其他线程拿走元素
if(size > queues.length){ // queue已经满了, 等待清楚
notFull.await(); // 这个 await 是响应线程中断的
}
// 2. 若堆中没有元素, 则直接在堆的头节点放入元素
if(size == 0){ // heap中没有数据
queues[0] = e;
}else{
queues[size] = e;
size++;
siftUp(size - 1, e);
}
notEmpty.signal();
} finally {
lock.unlock();
}
return true;
}
插入:
- 若heap没数据则直接将元素放置头节点, ok
- 若heap有元素, 则将元素放置到为节点, 在调用 siftUp 进行heap调整(那什么是 siftUp 调整呢, 我们接下来看)
向上调整
/**在数组中插入元素x到下标为k的位置, 为保持堆的性质,
* 通过siftUp来进行调整, 直到x大于或等于x的 parent的值或到root节点
*
* @param k
* @param x
*/
private void siftUp(int k, E x){
Comparable<? super E> key = (Comparable<? super E>)x;
while(k > 0){
int parent = parent(k); // 获取对应的父节点的下标
Object e = queues[parent]; // 获取对应的父节点对应的值
// 将当前节点与父节点的值进行比较
// 若当前节点比其父节点大, 则说明不在需要在向上 sift 比较了
//
if(key.compareTo((E) e) >= 0){
break;
}
queues[k] = e; // 将父节点下沉
k = parent; // 将这次比较的父节点赋值给k, 为下次 k 与其父节点作比较而准备
}
// 这里的k 有可能是最初节点 x的父节点, 也有可能就是x节点父节点的下标
queues[k] = key;
}
siftUp:
整个逻辑比较简单: 将当前节点与父节点进行比较, 不满足堆特性的进行调整, 直到满足为止
删除元素
/**
* 获取队列中的头节点
* @return
* @throws InterruptedException
*/
public E take() throws InterruptedException{
/**
* 1. 直接将头节点获取
* 2. 将队列中的尾节点拿出来, 从节点0开始siftdown -> 调整heap,使得,这个堆的最小值还在heap的顶上
*/
E result = null;
lock.lockInterruptibly();
try {
// 1. 若heap为空, 则等待, 直到有数据
if(size == 0){ // heap中没数据
notEmpty.await(); // 等待放入数据
return null;
}
int s = size - 1;
// 2. 将heap的头节点拿出来
result = (E)queues[0];
// 3. 将heap的尾节点拿出来, 若堆中还有元素, 在从(index=0)从开始siftdown调整堆
E x = (E)queues[s];
queues[s] = null;
if(s != 0){
siftDown(0, x);
}
size--;
notFull.signal(); // 进行唤醒
} finally {
lock.unlock();
}
return result;
}
删除元素:
- 直接将头节点获取
- 将队列中的尾节点拿出来, 从节点0开始siftdown -> 调整heap,使得,这个堆的最小值还在heap的顶上,那什么是siftDown, 我们接着看(其实和siftUp差不多)
堆向下调整
/**
* 插入元素x到位置k, 为保持二叉堆的特性, 对x进行siftDown, 直到x<=子节点
* @param k
* @param x
*/
private void siftDown(int k, E x){
Comparable<? super E> key = (Comparable<? super E>)x;
int half = parent(size -1); // 最后一个节点的父节点下标
while(k < half){
// 1. 获取子节点的坐标, 并取出两者中的最小值
int child = leftChildIndex(k);
Object c = queues[child];
int right = child + 1;
// 2. 选中子节点中最小的那个节点进行比较
if(right < size -1 ){
Object r = queues[right];
if(((E)c).compareTo((E)r) >= 1) {
c = queues[child = right];
}
}
// 3. 若节点小于子节点, 则比较结束
if(key.compareTo((E) c) <= 0){
break;
}
queues[k] = c; // 将子节点上行
k = child; // 父节点的光标下移, 为下次比较准备
}
queues[k] = key;
}
siftDown:整个逻辑比较简单: 将当前节点子节点进行比较, 不满足堆特性的进行调整, 直到满足为止
最后贴上上面代码的完整版本 Heap.java
总结:
二叉堆在java的运用比较广, 如PriorityQueue, DelayQueue内部实现都是基于二叉堆; 而难的地方个人觉得在主要在于堆的调整
- 元素进行插入时, 直接插入到尾节点, 再将尾节点进行向上调整, 直到根节点(整个调整其实就是swap值, 将最大/小放到根节点)
- 删除元素时, 将尾元素放置到头节点, 开始向下调整
