二叉堆 Binary Heap
满二叉树：除了叶子节点，其他所有节点 左右孩子均不为空
性质：
-
二叉堆是一棵完全二叉树 ( 若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数（x层：2^(x-1)个），第 h 层所有的结点都连续集中在最左边，这就是完全二叉树 )
-
二叉堆是 最大堆(堆中某个节点的值总是不大于其父节点的值)。即根节点的元素是最大的。(从堆中去除元素只能取堆顶的元素)
可以将这个 二叉堆（最大堆） 用 数组 来表示。一层一层元素从左往右放入数组。
1. 最大堆的实现：
用 数组 来实现
private Array<E> data;
public MaxHeap(int capacity){
data = new Array<>(capacity);
}
//将数组直接传入转换为最大堆
public MaxHeap(E[] arr){
data = new Array<>(arr);
for(int i = parent(arr.length - 1) ; i >= 0 ; i --)
siftDown(i);
}
// 返回堆中的元素个数
public int size(){
return data.getSize();
}
// 返回一个布尔值, 表示堆中是否为空
public boolean isEmpty(){
return data.isEmpty();
}
// 返回完全二叉树的数组表示中，一个索引所表示的元素的父亲节点的索引
private int parent(int index){
if(index == 0)
throw new IllegalArgumentException("index-0 doesn't have parent.");
return (index - 1) / 2;
}
// 返回完全二叉树的数组表示中，一个索引所表示的元素的左孩子节点的索引
private int leftChild(int index){
return index * 2 + 1;
}
// 返回完全二叉树的数组表示中，一个索引所表示的元素的右孩子节点的索引
private int rightChild(int index){
return index * 2 + 2;
}
其中 [siftDown()](#下沉 siftDown()) 函数 见下面解释 。
2. 添加元素 O(logn)
add() 方法。
在堆中添加元素，应该把元素添加在最后面，即相当于数组末端添加。
上浮 siftUp()
添加之后，需要进行判断排序。调用 siftUp() 函数来上浮：
-
先将元素添加到 堆 的最后。可知，这里的最后，即为堆最深一层第一个为空的节点。
-
开始讲该节点上浮，进行循环判断。
-
k > 0 即节点未到堆顶，并且 父节点 小于 该节点 的值 时 ，交换 位置
-
以此循环
// 向堆中添加元素 public void add(E e){ data.addLast(e); siftUp(data.getSize() - 1); } private void siftUp(int k){ // while(k > 0 && data.get(parent(k)).compareTo(data.get(k)) < 0 ){ data.swap(k, parent(k)); k = parent(k); } }
3. 堆元素的取出 O(logn)
extract() 。只取堆顶最大的元素。
思路：
- 将堆最后面的那个元素移到堆顶，保持完全二叉树的状态不变；
- 将这个完全二叉树变成最大堆。用堆顶元素和左右孩子进行比较，如果左右孩子更大的元素比该堆顶元素还大，就交换位置；
- 循环下沉，与左右孩子比较直到左右孩子均小于这个元素。
下沉 siftDown()
// 看堆中的最大元素
public E findMax(){
if(data.getSize() == 0)
throw new IllegalArgumentException("Can not findMax when heap is empty.");
return data.get(0);
}
// 取出堆中最大元素
public E extractMax(){
E ret = findMax();
data.swap(0, data.getSize() - 1);
data.removeLast();
siftDown(0);
return ret;
}
//下沉
private void siftDown(int k){
//节点值未超出最大值
while(leftChild(k) < data.getSize()){
int j = leftChild(k); // 在此轮循环中,data[k]和data[j]交换位置
if( j + 1 < data.getSize() &&
data.get(j + 1).compareTo(data.get(j)) > 0 )
j ++;
// data[j] 是 leftChild 和 rightChild 中的最大值
if(data.get(k).compareTo(data.get(j)) >= 0 )
break;
data.swap(k, j);
k = j;
}
}
4. heapify O(n)
将任意 数组 整理成 堆 的形状。
本例在构造函数里用。
如果采用一个一个 add()， 那时间复杂度就是 O(nlogn)
采用以下方法：从倒数第二层开始，时间复杂度 O(n)
思路：
-
先把数组顺序当成完全二叉树
-
从最后一个非叶子节点
int i = parent(arr.length - 1)开始，按坐标递减，逐层往上对所有元素进行siftDown()
public MaxHeap(E[] arr){
data = new Array<>(arr);
//
for(int i = parent(arr.length - 1) ; i >= 0 ; i --)
siftDown(i);
}
5. replace
取出最大元素后，放入一个新元素。
实现：
可以直接将堆顶元素替换以后Sift Down，一次O（logn）的操作
//取出堆中的最大元素，并且替换成元素e
public E replace(E e){
E ret = findMax();
data.set(0, e);
siftDown(0);
return ret;
}
优先队列
public class PriorityQueue<E extends Comparable<E>> implements Queue<E>
继承 Comparable< E > 类，实现compareTo() 方法。 来进行优先级的比较。
对于一个最大堆来说，堆顶是优先级最高的元素。元素越大，优先级越高；相反，最小堆，元素越小，优先级越高
这里用堆来实现的。
最大堆和最小堆实现 ，compareTo() 方法将返回相反的值
topK 问题
LeetCode347
题目最终需要返回的是前 kk 个频率最大的元素，可以想到借助堆这种数据结构，对于 kk 频率之后的元素不用再去处理，进一步优化时间复杂度。
具体操作为：
- 借助 哈希表 来建立数字和其出现次数的映射，遍历一遍数组统计元素的频率
- 维护一个元素数目为 k 的最小堆
- 每次都将新的元素与堆顶元素（堆中频率最小的元素）进行比较
- 如果新的元素的频率比堆顶端的元素大，则弹出堆顶端的元素，将新的元素添加进堆中
- 最终，堆中的 kk 个元素即为前 kk 个高频元素
扩展：
1. d 叉堆 (d-aray heap) ：
2. 索引堆：
3. 二项堆：
4. 斐波那契堆：
5. 广义队列
栈，也可以看做是队列
普通队列， 优先队列， 随机队列