二叉堆定義
二叉堆是一種特殊的堆, 二叉堆是完全二叉樹或者近似完全二叉樹. 二叉堆滿足堆特性: 父節點的鍵值總是保持固定的序關系于任何一個子節點的鍵值(就是父節點大/小于子節點), 且每個節點的左子樹和右子樹都是一個二叉堆.
當父節點的鍵值總是大于或等于任何一個子節點的鍵值時為最大二叉堆. 當父節點的鍵值總是小于或等于任何一個子節點的鍵值時為最小堆
二叉堆的表現形式
二叉堆一般用數組來表示. 如果節點在數組中的位置是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值, 將最大/小放到根節點)
- 刪除元素時, 將尾元素放置到頭節點, 開始向下調整
