1、前言
1、优先队列，底层通过数组来构造树（二叉树) 来实现的。
2、默认是最小堆（取出来的是最小值)，可以通过传入一个比较器 comparator 来构造一个最大堆。
3、传入的参数不能为空，否则抛出NPE问题。
4、最大堆的特性是左右孩子的值都比父节点小， 最小堆是左右节点值都比父节点大，利用该特性可以用来解决一些topK问题
2、关键常量
// 初始化容量
private static final int DEFAULT_INITIAL_CAPACITY = 11;
// 最小堆和最大堆的比较器， 默认是最小堆
private final Comparator<? super E> comparator;
// 数据存储的数组，构造成树后，节点在数组的index 可以通过以下公式求出
// leftNo = parentNo*2+1 左节点的index
// rightNo = parentNo*2+2 右节点的index
// parentNo = (nodeNo-1)/2 //父节点的index , nodeNo当前节点的index
transient Object[] queue;
// 最大数组可分配的大小， 这里 - 8 是因为一些虚拟机在数组中会保留头部字段，
// 如果不 -8，分配大小的时候有可能导致OutOfMemoryError
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;3、源码解析
下边记录下对一些方法的理解。
3.1、扩容
/**
* 扩容
*
* @param minCapacity 期望的最小容量
*/
private void grow(int minCapacity) {
int oldCapacity = queue.length;
// 扩容两倍，如果还是小，那么而外加 50%
int newCapacity = oldCapacity + ((oldCapacity < 64) ?
(oldCapacity + 2) :
(oldCapacity >> 1));
// 防止新容量大于数组的最大容量
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
queue = Arrays.copyOf(queue, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // 最小容量 < 0 ，抛出异常
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}3.2、add 方法
public boolean add(E e) {
return offer(e);
}
/**
* 入队，不能插入 null 元素
*/
public boolean offer(E e) {
// 传入null元素，抛异常
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 siftUp(int k, E x) {
if (comparator != null)
siftUpUsingComparator(k, x);
else
siftUpComparable(k, x);
}
/**
* 最小堆的结构调整,从k指定的位置开始，
* 将x逐层与当前点的parent进行比较并交换，直到满足x >= queue[parent]为止。
* 注意这里的比较可以是元素的自然顺序，也可以是依靠比较器的顺序。
*/
private void siftUpComparable(int k, E x) {
Comparable<? super E> key = (Comparable<? super E>) x;
// k 指定的位置index
while (k > 0) {
// 根据公式求出 parentNo = (nodeNo-1)/2 父节点的 index
int parent = (k - 1) >>> 1;
Object e = queue[parent];
// 从k当前位置的parent进行值比较，如果x 大于 parent 就停止循环。(最小堆子节点不能小于父节点）
if (key.compareTo((E) e) >= 0)
break;
// 交换值
queue[k] = e;
k = parent;
}
queue[k] = key;
}
/*
* @link siftUpComparable() 方法差不多，根据传入比较器值的大小来进行堆的结构调整
* 可能是最大堆，也可能是最小堆
*/
private void siftUpUsingComparator(int k, E x) {
while (k > 0) {
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;
}关于堆siftUp的结构调整，如下图所示：（图来自https://github.com/CarpenterLee/JCFInternals/blob/master/markdown/8-PriorityQueue.md）
3.3、peek()
// 获取堆顶元素
public E peek() {
return (size == 0) ? null : (E) queue[0];
}3.4、poll()
/*
* 弹出堆的第一个元素，同时将最后一个元素置 null , 然后进行堆的结构调整，向下调整。
*/
public E poll() {
if (size == 0)
return null;
int s = --size;
modCount++;
// 获取堆第一个元素
E result = (E) queue[0];
// 获取堆最后一个元素，将其置null
E x = (E) queue[s];
queue[s] = null;
// 堆的结构调整
if (s != 0)
siftDown(0, x);
return result;
}
/**
* 插入 x 的值放在 k 的位置上，为了保证堆的特性，根据比较器来进行调整堆的结构。
*
* @param k 要插入的位置
* @param x 要插入的值
*/
private void siftDown(int k, E x) {
if (comparator != null)
siftDownUsingComparator(k, x);
else
siftDownComparable(k, x);
}
/*
* 堆结构向下调整，从k指定的位置开始，
* 将x逐层向下与当前点的左右孩子中较小的那个交换，直到x小于或等于左右孩子中的任何一个为止。
*/
private void siftDownComparable(int k, E x) {
Comparable<? super E> key = (Comparable<? super E>)x;
// 获取数组的中点位置
int half = size >>> 1; // loop while a non-leaf
while (k < half) {
// 获取k左孩子的index(假设左孩子是最小的)
int child = (k << 1) + 1;
Object c = queue[child];
// 获取k右孩子的index, 为左孩子index + 1
int right = child + 1;
// 将 x 逐层向下与当前点的左右孩子中较小的那个交换，
// 直到 x 小于或等于左右孩子中的任何一个为止
if (right < size &&
((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
// 左右孩子最小节点的值
c = queue[child = right];
// 如果父节点比孩子节点还小，则结束循环
if (key.compareTo((E) c) <= 0)
break;
// 交互当前父节点和比较小节点的值
queue[k] = c;
// 记录孩子节点的index， 继续循环
k = child;
}
// 最终把k节点，也就是父节点放在合适的位置上，维持堆的特性
queue[k] = key;
}
/*
* 根据用户构造的比较器，向下调整堆结构，从k指定的位置开始，
* 将x逐层向下与当前点的左右孩子中较小的那个交换，直到x小于或等于左右孩子中的任何一个为止。
*/
private void siftDownUsingComparator(int k, E x) {
// 获取数组的中点位置
int half = size >>> 1;
while (k < half) {
int child = (k << 1) + 1;
Object c = queue[child];
int right = child + 1;
if (right < size &&
// 使用用户自定义的比较器进行比较
comparator.compare((E) c, (E) queue[right]) > 0)
c = queue[child = right];
if (comparator.compare(x, (E) c) <= 0)
break;
// 交换值
queue[k] = c;
k = child;
}
queue[k] = x;
}
关于堆的向下调整大概图，如下所示：（图来着https://github.com/CarpenterLee/JCFInternals/blob/master/markdown/8-PriorityQueue.md）
3.5、remove()
// 删除元素，如果元素不存在，返回false
public boolean remove(Object o) {
int i = indexOf(o);
if (i == -1)
return false;
else {
removeAt(i);
return true;
}
}
// 遍历查找元素是否存在于队列中，存在则返回其索引 ，否则返回-1
private int indexOf(Object o) {
if (o != null) {
for (int i = 0; i < size; i++)
if (o.equals(queue[i]))
return i;
}
return -1;
}
// 根据索引删除元素
private E removeAt(int i) {
// 假设索引大于等于0， 同时索引小于数组大小
modCount++;
int s = --size;
// 如果元素刚好是最后一个，直接置 null 即可
if (s == i)
queue[i] = null;
else {
// 找到最后的一个元素，保存最后一个元素的值，然后删除该值
E moved = (E) queue[s];
queue[s] = null;
// 这时候需要向下调整堆的结构
siftDown(i, moved);
// 如果当前索引i的值还等于调整前最后一个元素的值
if (queue[i] == moved) {
// 向上调整
siftUp(i, moved);
// 调整完之后，如果当前索引i的值不等于调整前最后一个元素的值
if (queue[i] != moved)
// 返回删除的元素的值
return moved;
}
}
// 没找到，返回null
return null;
}remove（i）堆调整的大概图如下所示：（图来自https://github.com/CarpenterLee/JCFInternals/blob/master/markdown/8-PriorityQueue.md）
手动结束线~~~~~~~
对于其它方法，感兴趣的朋友可以自行去研究下。
4、参考
JCFInternals/markdown/8-PriorityQueue.md at master · CarpenterLee/JCFInternals · GitHub大佬的集合源码分析，写的很nice,图都来自这上面的。
![C. Alternating Subsequence[双指针，贪心]](https://i-blog.csdnimg.cn/direct/ff8e4223ed434aae99c89b5d955eaba7.png#pic_center)
