JDK学习笔记之PriorityQueue

PriorityQueue是基于堆的 有限队列，这个队列里面的元素按照顺序排列，排序规则可以是元素自己的排序规则，也可以在创建堆的时候创建一个比较器，用这个比较器的规则进行排序。
优先队列不可以存放null元素。
该数据结构继承了抽象类AbstractQueue

public class PriorityQueue<E> extends AbstractQueue<E>
    implements java.io.Serializable

private static final int DEFAULT_INITIAL_CAPACITY = 11;

默认初始容量为11

transient Object[] queue;

Object数组存储元素。

private int size = 0;

元素个数。

private final Comparator<? super E> comparator;

比较器。

transient int modCount = 0;

修改次数。

public PriorityQueue() {
    this(DEFAULT_INITIAL_CAPACITY, null);
}

无参构造器，null指的是不传入比较器。

public PriorityQueue(int initialCapacity) {
    this(initialCapacity, null);
}

设置初始容量的构造器，同样不传入比较器。

public PriorityQueue(Comparator<? super E> comparator) {
    this(DEFAULT_INITIAL_CAPACITY, comparator);
}

传入比较器的构造器。

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;
}

传入初始容量和比较器的构造器，其他构造器最终都调用了这个构造器，该构造器中初始化了queue数组和比较器。

public boolean add(E e) {
    return offer(e);
}

单纯地调用offer

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;
}

一般情况下，会调用siftUp方法。

private void siftUp(int k, E x) {
    if (comparator != null)
        siftUpUsingComparator(k, x);
    else
        siftUpComparable(k, x);
}

如果自身比较器不为空，用比较器排序。

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;
}

使用的是堆排序的方式，堆排序把堆模拟成一颗完全二叉树。对于任意一个节点下标k，其父节点下标为(k-1)/2。比较这个父节点元素和插入的元素大小，父节点元素小于插入的子节点元素（假如按升序排序），说明不需要调整顺序，直接break，否则调换父节点和子节点的位置，并进行下一轮比较。本质就是插入的节点放在叶节点，然后依次向上调整到合适的位置。

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 heapify() {
    for (int i = (size >>> 1) - 1; i >= 0; i--)
        siftDown(i, (E) queue[i]);
}

在一次放入多个元素时，进行建堆操作，建堆操作时从数组的中间开始向前遍历，每次向下调整。从二叉树的角度来看就是从倒数第二层节点开始，每次比较节点和其子节点的值并调整，依次向上遍历直到树的根节点。

private void siftDown(int k, E x) {
    if (comparator != null)
        siftDownUsingComparator(k, x);
    else
        siftDownComparable(k, 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;
}

每次调整需要将当前节点一直向下调整到合适的位置，可能一直调整到叶节点的位置为止，这取决于节点值的大小。

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 grow(int minCapacity) {
    int oldCapacity = queue.length;
    // Double size if small; else grow by 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);
}

优先队列的扩容策略，如果当前容量小于64，则容量变为二倍加二，否则变为当前容量的1.5倍。
如果新容量比最大容量大，调用hugeCapacity方法。

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

传入参数大于最大数组长度，则返回int的最大值，否则返回数组最大长度。
总结就是每次扩容提供一个参数minCapacity，如果按照默认扩容规则没有超过数组最大长度，则minCapacity用不到，直接扩容。如果超过数组最大长度，如果传入参数minCapacity也超过了最大长度，返回int的最大值，否则返回数组最大长度。

private E removeAt(int i) {
    // assert i >= 0 && i < size;
    modCount++;
    int s = --size;
    if (s == i) // removed last element
        queue[i] = null;
    else {
        E moved = (E) queue[s];
        queue[s] = null;
        siftDown(i, moved);
        if (queue[i] == moved) {
            siftUp(i, moved);
            if (queue[i] != moved)
                return moved;
        }
    }
    return null;
}

优先队列提供的删除元素操作，按照数组下标删除。
如果删除的是最后一个元素，直接size-1且将最后一个数组元素置空。
否则用moved存储最后一个元素，将该数组元素置空。
把moved放在待删除的数组下标向下调整，调整完如果发现没有变化，说明moved比现在的子节点都大，那么再向上调整。如果发生了调整，返回moved，其他情况都返回null。
就是把最后一个元素移到待删除的位置，然后向下调整，如果调不动再向上调整。因为对堆中的任意元素而言，其上的元素都比它大，其下的元素都比它小，上面的元素都比下面的元素要大，所以替换成另一个元素时，这个元素要么向下调整，要么向上调整，不可能向下调整之后再向上调整。