集合框架系列 Queue（八）：PriorityQueue

目录

1 概述

2 源码分析

1 概述

PriorityQueue 是一个优先级队列，其底层原理采用二叉堆实现。我们先来看看它的类声明：

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

PriorityQueue 继承了 AbstractQueue 抽象类，具有队列的基本特性。

2 源码分析

2.1 类成员变量

// 队列数据
transient Object[] queue;  
// 大小
private int size = 0;
// 比较器
private final Comparator<? super E> comparator;

从类成员变量我们可以知道 PriorityQueue 底层采用数组存储数据，comparator 的实现决定了其实一个最大堆还是最小堆。默认情况下 PriorityQueue 是个最小堆。

2.2 构造方法

PriorityQueue 一共有 7 个构造方法。

public PriorityQueue() {
    this(DEFAULT_INITIAL_CAPACITY, 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) { 
    if (initialCapacity < 1)
        throw new IllegalArgumentException();
    this.queue = new Object[initialCapacity];
    this.comparator = comparator;
}
// 传入集合初始值
public PriorityQueue(Collection<? extends E> c) {
    if (c instanceof SortedSet<?>) {
        SortedSet<? extends E> ss = (SortedSet<? extends E>) c;
        this.comparator = (Comparator<? super E>) ss.comparator();
        initElementsFromCollection(ss);
    }
    else if (c instanceof PriorityQueue<?>) {
        PriorityQueue<? extends E> pq = (PriorityQueue<? extends E>) c;
        this.comparator = (Comparator<? super E>) pq.comparator();
        initFromPriorityQueue(pq);
    }
    else {
        this.comparator = null;
        initFromCollection(c);
    }
}
// 传入PriorityQueue初始值
public PriorityQueue(PriorityQueue<? extends E> c) {
    this.comparator = (Comparator<? super E>) c.comparator();
    initFromPriorityQueue(c);
}
// 传入SortedSet初始值
public PriorityQueue(SortedSet<? extends E> c) {
    this.comparator = (Comparator<? super E>) c.comparator();
    initElementsFromCollection(c);
}

PriorityQueue 的构造方法比较多，但其功能都类似。如果传入的是普通集合，那么会将其数据复制，最后调用 heapify 方法进行二叉堆的初始化操作。但如果传入的数据是 SortedSet 或 PriorityQueue 这些已经有序的数据，那么就直接按照顺序复制数据即可。

2.3 核心方法

对于 PriorityQueue 来说，其核心方法有：获取、插入、删除、扩容。

2.3.1 获取

PriorityQueue 没有查询方法，取而代之的是获取数据的 peek 方法。

public E peek() {
    return (size == 0) ? null : (E) queue[0];
}

如果队列为空，那么返回 null 值，否则返回队列的第一个元素（即最大或最小值）。

2.3.2 插入

PriorityQueue 的数据插入过程，其实就是往二叉堆插入数据的过程。

public boolean add(E e) {
    return offer(e);
}
    
public boolean offer(E e) {
    if (e == null)
        throw new NullPointerException();
    modCount++;
    int i = size;
    // 1.容量不够，进行扩容
    if (i >= queue.length)
        grow(i + 1);
    size = i + 1;
    // 2.如果队列为空那么直接插入第一个节点
    // 否则插入末尾节点后进行上浮操作
    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
        // 3.采用默认的比较器
        siftUpComparable(k, x);
}
    
private void siftUpComparable(int k, E x) {
    Comparable<? super E> key = (Comparable<? super E>) x;
    while (k > 0) {
        // 4.将插入节点与父节点比较
        // 如果插入节点大于等于父节点，那么说明符合最小堆性质
        // 否则交换插入节点与父节点的值，一直到堆顶
        int parent = (k - 1) >>> 1;
        Object e = queue[parent];
        if (key.compareTo((E) e) >= 0)
            break;
        queue[k] = e;
        k = parent;
    }
    queue[k] = key;
}

插入的代码最终的逻辑是在 siftUpComparable 方法中，而该方法其实就是我们上面所说二叉堆插入逻辑的实现。

2.3.3 删除

PriorityQueue 的数据删除过程，其实就是将数据从二叉堆中删除的过程。

public boolean remove(Object o) {
    int i = indexOf(o);
    if (i == -1)
        return false;
    else {
        removeAt(i);
        return true;
    }
}
    
private E removeAt(int i) {
    // assert i >= 0 && i < size;
    modCount++;
    int s = --size;
    // 1.删除的是末尾节点，那么直接删除即可
    if (s == i) // removed last element
        queue[i] = null;
    else {
        E moved = (E) queue[s];
        queue[s] = null;
        // 2.对删除节点做下沉操作
        siftDown(i, moved);
        if (queue[i] == moved) {
            // 3.queue[i] == moved 表示删除节点根本没下沉
            // 意思是其就是该子树最小的节点
            // 这种情况下就需要进行上浮操作
            // 因为可能出现删除节点父节点大于删除节点的情况
            siftUp(i, moved);
            if (queue[i] != moved)
                return moved;
        }
    }
    return null;
}
    
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;
}

2.3.4 offer

因为 PriorityQueue 是队列，所以有 offer 操作。

对于 offer 操作来说，其实就是相当于往数组未插入数据，其逻辑细节我们在插入 add 方法中已经说到。

2.3.5 poll

因为 PriorityQueue 是队列，同样会有 poll 操作。而 poll 操作其实就是弹出队列头结点，相当于删除头结点。

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

PriorityQueue 的扩容非常简单。如果原来的容量小于 64，那么扩容为原来的两倍，否则扩容为原来的 1.5 倍。

3 总结

PriorityQueue 的实现是建立在二叉堆之上的，所以弄懂二叉堆就相当于弄懂了 PriorityQueue。PriorityQueue 默认情况下是最小堆，我们可以改变传入的比较器，使其成为最大堆。

0