完全二叉樹 & 滿二叉樹 & 堆
基本概念
滿二叉樹是指除了最後一層外，每個節點都有兩個孩子，而最後一層都是葉子節點，都沒有孩子。
滿二叉樹一定是完全二叉樹，但完全二叉樹不要求最後一層是滿的，但如果不滿，則要求所有節點必須集中在最左邊，從左到右是連續的，中間不能有空的。
特點
在完全二叉樹中，可以給每個節點一個編號，編號從1開始連續遞增，從上到下，從左到右
完全二叉樹有一個重要的特點：給定任意一個節點，可以根據其編號直接快速計算出其父節點和孩子節點。如果編號爲i，則父節點編號爲i/2，左孩子編號爲2*i，右孩子編號爲2*i+1
它使得邏輯概念上的二叉樹可以方便地存儲到數組中，數組中的元素索引就對應節點的編號，樹中的父子關係通過其索引關係隱含維持，不需要單獨保持。
這種存儲二叉樹的方法與之前介紹的TreeMap是不一樣的。在TreeMap中，有一個單獨的內部類Entry，Entry有三個引用，分別指向父節點、左孩子、右孩子。使用數組存儲的優點是節省空間，而且訪問效率高。
堆
堆邏輯概念上是一棵完全二叉樹，而物理存儲上使用數組，還要一定的順序要求。
TreeMap內部使用的是排序二叉樹原理，排序二叉樹是完全有序的，每個節點都有確定的前驅和後繼，而且不能有重複元素。與排序二叉樹不同，在堆中，可以有重複元素，元素間不是完全有序的，但對於父子節點直接，有一定的順序要求。根據順序分爲兩種堆：最大堆、最小堆
最大堆是指每個節點都不大於其父節點。這樣，對於每個父節點，一定不小於其所有孩子節點，那麼根節點就是所有節點中最大的了。最小堆與最大堆就正好相反，每個節點都不小於其父節點。
總結來說：堆是完全二叉樹，父子節點間有特定順序，分爲最大堆和最小堆，堆使用數組進行物理存儲。
堆的操作
添加元素
這裏我們以最小堆爲例進行講解
如果堆爲空，則直接添加一個根就行了。
如果堆不爲空，要在其中添加元素，基本步驟爲：
1. 添加元素到最後位置
2. 與父節點比較，如果大於等於父節點，則滿足堆的性質，結束。否則與父節點進行交換，然後再與父節點比較和交換，直到父節點爲空或者大於等於父節點。
該方法稱爲向上調整
添加一個元素，需要比較和交換的次數最多爲樹的高度，即log(N)。N爲節點數
從頭部刪除元素
- 用最後一個元素替換頭部元素，並刪掉最後一個元素
- 將新的頭部與兩個孩子節點中較小的比較，如果不大於該孩子節點，則滿足堆的性質，結束。否則與較小的孩子節點進行交換，交換後，再與較小的孩子節點比較，一直到沒有孩子節點或者不大於兩個孩子節點。
該方法稱爲向下調整
從中間刪除元素
- 與從頭部刪除一樣，先用最後一個元素替換待刪元素。
- 有兩種情況，如果該元素大於某孩子節點，則需要向下調整；如果小於父節點，則需要向上調整。
查找和遍歷
在堆中進行查找沒有特殊的算法，就是從數組的頭找到尾，效率爲O(N)
在堆中進行遍歷也是類似的。
構建堆
給定一個無序數組，如何使之成爲一個最小堆呢？
基本思路是：從最後一個非葉子節點開始，一直往前直到根，對每個節點，執行向下調整。換句話說，自底向上。先使每個最小子樹爲堆，然後對左右子樹和其父節點合併，調整爲更大的堆，因爲每個子樹已經爲堆，所以調整就是堆父節點執行向下調整，這樣一直合併調整到根。
小結
- 在添加和刪除元素時，效率爲O(logN)
- 查找和遍歷元素，效率爲O(N)
- 構建堆的效率是O(N)
PriorityQueue
PriorityQueue是優先級隊列，實現了隊列接口（Queue），內部是用堆實現的，內部元素不是完全有序的，不過，逐個出對會得到有序的輸出。
基本用法
PriorityQueue有多個構造方法：
public PriorityQueue();
public PriorityQueue(int initialCapacity, Comparator<? super E> comparator);
public PriorityQueue(Collection<? extends E> c);PriorityQueue是用堆實現的，堆物理上就是數組，與ArrayList類似，都是使用動態數據，根據元素的個數進行動態擴展，initialCapacity表示初始化的數組大小，默認爲11。與TreeMap/TreeSet類似，爲了保持一定順序，PriorityQueue要求要麼元素實現Comparable接口，要麼傳遞一個比較器Comparator。
實現原理
先看看內部組成成員：
// 實際存儲元素的數組
private transient Object[] queue;
// 當前元素個數
private int size = 0;
// 比較器，可以爲null
private final Comparator<? super E> comparator;
// 修改次數
private transient int modCount = 0;構造方法上面已經提到過了，主要是初始化queue和comparator 。 操作相關的代碼和上面的堆的操作差不多的，這裏我們以入隊爲例，做一個簡單的講解
public boolean offer(E e) {
if (e == null)
throw new NullPointerException();
modCount++;
int i = size;
// 確保數組長度是夠的
if (i >= queue.length)
grow(i + 1);
// 元素長度增加
size = i + 1;
// 如果第一次添加，直接放在第一個位置
if (i == 0)
queue[0] = e;
// 否則將其放入最後一個位置，並向上調整
else
siftUp(i, e);
return true;
}
private void grow(int minCapacity) {
int oldCapacity = queue.length;
// Double size if small; else grow by 50%
// 如果原來長度比較小，擴展爲兩倍，否則就增加50%
int newCapacity = oldCapacity + ((oldCapacity < 64) ?
(oldCapacity + 2) :
(oldCapacity >> 1));
// overflow-conscious code
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
queue = Arrays.copyOf(queue, newCapacity);
}
/**
* 向上調整
*/
private void siftUp(int k, E x) {
// 如果有比較器就用比較器
if (comparator != null)
siftUpUsingComparator(k, x);
else
siftUpComparable(k, x);
}
/**
* 向上尋找x真正應該插入的位置
* @param k 表示插入的位置
* @param x 表示新元素
*/
private void siftUpUsingComparator(int k, E x) {
while (k > 0) {
// 父節點位置，當前節點位置/2
int parent = (k - 1) >>> 1;
// 父節點
Object e = queue[parent];
// 如果新元素大於等於父節點，則滿足堆的性質，退出
if (comparator.compare(x, (E) e) >= 0)
break;
// 否則父元素下移，繼續向上尋找
queue[k] = e;
k = parent;
}
queue[k] = x;
}小結
- 實現了優先級隊列，最先出對的總是優先級最高的
- 優先級可以有相同的，內部元素不是完全有序的
- 查看頭部元素效率很高爲O(1)，入隊、出隊效率較高爲O(logN)，構建堆的效率爲O(N)
- 查找和刪除的效率比較低爲O(N)
堆和PriorityQueue的應用
問題
這裏先拋出兩個比較常見的問題，然後再用堆的思想來進行解決
1. 求前K個最大的元素，元素個數不確定，數據量可能很大，甚至源源不斷到來，但需要知道目前爲止最大的前K個元素
2. 求中值元素，中值不是平均值，而是排序後中間那個元素的值，同樣數據量可能很大，甚至源源不斷到來
求前K個最大的元素
一個簡單的思路是排序，排序後取最大的K個就可以了，排序可以使用Arrays.sort()方法，效率爲O(N*log(N))。Arrays.sort()使用的是經過調優的快速排序法 。
另一種思路是選擇，循環選擇K次，每次從剩下的元素中選擇最大值，效率爲O(N*K)，如果K值大於log(N)，就不如排序了。
不過這兩個思路都是假定所有元素都是已知的，而不是動態的。如果元素個數不確定，且源源不斷到來呢？
一個基本的思路是維護一個長度爲K的數組，最前面的K個元素就是目前最大的K個元素，以後每來一個新元素的時候，都先找到數組中最小值，將新元素與最小值相比，如果小於最小值，什麼都不用做；如果大於最小值，則將最小值替換爲新元素。
這類似於生活中常見的末尾淘汰。
這樣，數組中維護的永遠都是最大的K個元素，不管數據源有多少，需要的內存開銷是固定的，就是長度爲K的數組。不過，每來一個元素，都需要找最小值，都需要進行K次比較，能不能減少比較次數呢？
解決方法是使用最小堆維護這個K個元素，最小堆中，根即第一個元素永遠都是最小的，新來的元素與根比較就可以了，如果小於根，則堆不需要變化，否則用新元素替換根，然後向下調整堆即可，調整的效率爲O(logK)，總體效率就是O(N*logK)。而且使用了最小堆後，第K個最大的元素也很容易獲取，它就是堆的根
public class TopK<E> {
private PriorityQueue<E> p;
private int k;
public TopK(int k) {
this.k = k;
this.p = new PriorityQueue<>(k);
}
public void addAll(Collection<? extends E> c) {
for(E e: c) {
add(e);
}
}
public void add(E e) {
if(p.size() < k) {
p.add(e);
return ;
}
Comparable<? super E> head = (Comparable<? super E>)p.peek();
if(head.compareTo(e)>0) {
// 小於TopK中的最小值，不用變
return ;
}
// 新元素替換掉原來最小值成爲TopK之一
p.poll();
p.add(e);
}
public <T> T[] toArray(T[] a) {
return p.toArray(a);
}
public E getKth() {
return p.peek();
}
}求中值
中值就是排序後中間那個元素的值，如果元素個數爲奇數，中值是沒有歧義的，如果是偶數，可以爲偏小的，也可以爲偏大的。
一個簡單的思路就是排序，排序後取中間的那個值就可以了。排序可以使用Arrays.sort()方法，效率爲O(N*log(N))。
當然，這是要在數據源已知的情況下才能做到的。如果數據源源不斷到來呢？
可以使用兩個堆，一個最大堆，一個最小堆
1. 假設當前的中位數爲m，最大堆維護的是<=m的元素，最小堆維護的是>=m的元素，但兩個堆都不包含m。
2. 當新的元素到達時，比如爲e，將e與m進行比較，若e<=m，則將其加入最大堆中，否則加入最小堆中
3. 如果此時最小堆和最大堆的元素個數相差>=2，則將m加入元素個數少的堆中，然後從元素個數多的堆將根節點移除並賦值給m。
給個示例解釋一下，輸入的元素依次是：34，90，67，45，1
1. 輸入第一個元素時，m賦值爲34
2. 輸入第二個元素時，90>34，把90加入最小堆，m不變
3. 輸入第三個元素時，67>34，把67加入最小堆，此時最小堆根節點爲67。但是現在最小堆中元素個數爲2，最大堆中元素個數爲0，所以需要做調整，把m(34)加入個數少的堆中（最大堆），然後從元素個數多的堆（最小堆）將根節點移除並賦值給m，所以現在m爲67，最大堆中有34，最小堆中有90
4. 輸入第四個元素時，45<67，把45加入最大堆，m不變
5. 輸入第五個元素時，1<67，把1加入最大堆中，此時m爲67，最大堆中有1，34，45，最小堆中有90，所以需要調整。調整後，m爲45，最大堆爲1，34，最小堆爲67，90。
public class Median<E> {
// 最小堆
private PriorityQueue<E> minP;
// 最大堆
private PriorityQueue<E> maxP;
// 中值
private E m;
public Median() {
this.minP = new PriorityQueue<>();
this.maxP = new PriorityQueue<>(11, Collections.reverseOrder());
}
// 比較
private int compare(E e, E m) {
Comparable<? super E> cmpr = (Comparable<? super E>)e;
return cmpr.compareTo(e);
}
public void add(E e) {
if(m == null) {
// 第一個元素
m = e;
return ;
}
if(compare(e, m) < 0) {
// 如果e小於m，則加入最大堆
maxP.add(e);
} else {
// 如果e大於m，則加入最小堆
minP.add(e);
}
if(minP.size() - maxP.size() >= 2) {
// 最小堆中元素比最大堆中元素多2個
// 將m加入最大堆中，然後將最小堆中的根移除賦值給m
maxP.add(this.m);
this.m = minP.poll();
} else if(maxP.size() - minP.size() >= 2) {
minP.add(this.m);
this.m = maxP.poll();
}
}
public void addAll(Collection<? extends E> c) {
for(E e : c) {
add(e);
}
}
public E getM() {
return m;
}
}
