最近在项目开发中开发了全双工异步长连接的通讯组件，内部用到了延迟队列。而延迟队列的内部实现的存储是用到了优先队列，当时看C++的数据结构时，了解过优先队列，用的存储是二叉树的逻辑，应该叫完全二叉树，也可以叫做最大堆。
下面看一下二叉树的算法，主要看插入和删除。
二叉树顾名思义就像一棵树，每个节点下最多可以挂两个节点，如图
在优先队列中存储的方式就是 queue = {A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q};
若当前节点下标为i 那么它的子节点 左侧 = 2*i+1 右侧 = 2*i +2。优先队列顾名思义，就是优先权最大的排在队列的头部，而优先权的判断是根据对象的compare方法比较获取的，保证根节点的优先级一定比子节点的优先级大。所以放入到优先队列的元素要么实现了Comparable接口，要么在创造这个优先队列时，指定一个比较器。
下面我们来看一下优先队列的构造函数
private static final int DEFAULT_INITIAL_CAPACITY = 11;
private final Comparator<? super E> comparator;
public PriorityQueue() {
this(DEFAULT_INITIAL_CAPACITY, null);
}
public PriorityQueue(int initialCapacity,
Comparator<? super E> comparator) {
// Note: This restriction of at least one is not actually needed,
// but continues for 1.5 compatibility
if (initialCapacity < 1)
throw new IllegalArgumentException();
this.queue = new Object[initialCapacity];
this.comparator = comparator;
}在空构造器初始化时，数组队列的大小为11，比较器为null。这样的话，放入优先队列的对象要实现comparable接口，也可以判断队列中不能存放null元素。
现在我们来看一下往队列中添加一个对象的过程。
public boolean add(E e) {
return offer(e);
}
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;
}
可以看到，优先队列中不可能存在null元素,添加元素首先把队列修改次数++，判断是否超过内部数组的长度，超过后增加数组的长度 grow(i+1)
private void grow(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
int oldCapacity = queue.length;
// Double size if small; else grow by 50%
int newCapacity = ((oldCapacity < 64)?
((oldCapacity + 1) * 2):
((oldCapacity / 2) * 3));
if (newCapacity < 0) // overflow
newCapacity = Integer.MAX_VALUE;
if (newCapacity < minCapacity)
newCapacity = minCapacity;
queue = Arrays.copyOf(queue, newCapacity);
}如果数组长度小于64 是按照一倍长度增长的，长度超过64，每次增长原来的百分之50，如果长度超过了int的最大值，那就设置为
Integer.MAX_VALUE，如果新的长度小于需要增长的长度，就是设置成这个长度，最后复制原来的对象到新的数组。
这样数组长度扩展了，设置size+1。如果是空的优先队列，就把新元素添加到队列头部。如果不是空，那就根据compareTo来判断新加入的元素的优先级别，那么我们来看一下siftUp方法
private void siftUp(int k, E x) {
if (comparator != null)
siftUpUsingComparator(k, x);
else
siftUpComparable(k, x);
}
private void siftUpComparable(int k, E x) {
Comparable<? super E> key = (Comparable<? super E>) x;
while (k > 0) {
int parent = (k - 1) >>> 1;
Object e = queue[parent];
if (key.compareTo((E) e) >= 0)
break;
queue[k] = e;
k = parent;
}
queue[k] = key;
}
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;
}如果在创建队列的时候，指定了比较工具，那么就用比较器，比较器内部实现，可以根据自己的定义的比较原则，也可以调用加入队列的元素的compareTo方法（如果实现的话),比较方法变化自行定义。
我们主要看一下没有比较器的排序方法siftUpComparable，如下图
假设数字越小，优先级别越高，K的位置是新插入元素将要放置的位置，加入插入的是 25，那么此元素的优先级别小于它的父节点的优先级，直接把25放在K的位置。假如放置的是8，优先级别最高，所以 (k-1)>>>1 获取父节点，与父节点比较，发现优先级大于父节点，把父节点的值放入K, 把K的位置设置成父节点的下标值，递归查询父节点，定位出K的位置，把新元素放入此位置。此种二叉树算法大大降低了算法复杂度。
接下来我们看一下取走队列头部元素
public E poll() {
if (size == 0)
return null;
int s = --size;
modCount++;
E result = (E) queue[0];
E x = (E) queue[s];
queue[s] = null;
if (s != 0)
siftDown(0, x);
return result;
}
private void siftDown(int k, E x) {
if (comparator != null)
siftDownUsingComparator(k, x);
else
siftDownComparable(k, 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) {
int child = (k << 1) + 1; // assume left child is least
Object c = queue[child];
int right = child + 1;
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;
k = child;
}
queue[k] = key;
}
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;
}如果队列之有一个元素，就弹出这个元素，设置--size的位置为null。如果不是一个元素，弹出第一个元素，获取数组最后的一个元素，开始调用siftDown(0, x);我们先来看一下图解
这样到poll掉队列头部元素后，队列长度减一，所以最后的那个元素32的位置需要设置成null，这样一来，需要填补队列的头，由于子节点一定小于等于父节点的优先级，获取父节点的子节点
int child = (k << 1) + 1; // 获取左子节点的下标
Object c = queue[child]; // 获取左子节点
int right = child + 1; // 获取右子节点的下标但右子节点不一定存在所以下面做了一个右节点不会为null的判断，不为null的情况下，获取两个节点中优先级高的一个
if (right < size &&((Comparable<? super E>) c).compareTo((E) queue[right]) > 0){
c = queue[child = right];
}
//而下面这段代码的意思是可能出现如下图的情况
if (key.compareTo((E) c) <= 0){
break;
}
当21移到队列头部时，队列尾部的 32元素的优先级 大于68和67的优先级，可以直接把32元素放入到21的位置，直接结束循环，减少了下面空出元素的位置的重新排序算法。
用while（k<half) 因为k如果>=half 的话，此下标以下的节点无子节点，完全二叉树定义，也可以推到。
优先队列 也就这两个比较重要的方法，对于remove(Object o)方法，无非是删除中间节点后的一种先向下排序，再向上排序的过程，可以自行查看。
