Queue(队列)接口和其实现类PriorityQueue(优先级队列)源码解析

Posted 2020-11-27 linlf03

前面介绍的Stack是新进后出，而Queue是先进先出的

1、Queue结构

public interface Queue<E> extends Collection<E> {
   
    boolean add(E e);
   
    boolean offer(E e);

    E remove();

    E poll();

    E element();

    E peek();
}

　　Queue是一个接口。

 

2、PriorityQueue源码分析

PriorityQueue是一个优先队列，和先进先出的队列的区别是： 优先队列每次出队的元素都是优先级最高的元素。 如何确定哪一个元素的优先级呢？ jdk中使用堆这种数据结构，通过堆使得每次出队的元素总是队列里最小的，而元素大小的比较可以通过Compareator指定，相当于优先级。

 

3、什么是堆和二叉堆？

1) 堆中某个节点的值总是不大于或者不小于其父节点的值

2) 堆总是一颗完全树

场景的堆有二叉堆、斐波那契堆等。而PriorityQueue是二叉堆。

二叉堆是一种特殊的堆，二叉堆是完全二叉树或者近似完全二叉树。二叉堆有两种：最大堆和最小堆

最大堆： 父节点的键值总是大于或等于任何一个子节点的键值

最小堆：父节点的键值总是小于或者等于任何一个子节点的键值

二叉堆图例

 

 上图是一颗完全二叉树（二叉堆），特点是： 在第n层深度被填满之前，不会开始填第n+1层深度，而且元素插入是从左往右填满。

基于这个特点，二叉堆又可以用数组来表示而不是用链表。我们看一下下图用数组表示二叉堆

 

 基于数组实现的二叉堆，对于数组中任意元素的n上元素，其左孩子在2n+1位置上，右孩子在2n+2位置上，它的父节点在（n-1）/2上，而根节点是0的位置上。

 

4、PriorityQueue的数据结构，就是堆

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

    // 默认容量是11
    private static final int DEFAULT_INITIAL_CAPACITY = 11;

    //使用数组来存储元素
    transient Object[] queue; // non-private to simplify nested class access

    //队列元素大小 
    private int size = 0;
    //通过这个比较器实现优先级队列
    private final Comparator<? super E> comparator;
}

　　

5、构造函数

我们看主要的构造函数

public PriorityQueue(int initialCapacity, Comparator<? super E> comparator) {
    
	if (initialCapacity < 1)
	    throw new IllegalArgumentException();
	this.queue = new Object[initialCapacity];
    	this.comparator = comparator;

}

　　

6、二叉堆的添加原理

二叉堆的特点：

1）父结点的键值总是小于或等于任何一个子节点的键值。

2）基于数组实现的二叉堆，对于数组中任意元素的n上元素，其左孩子在2n+1位置上，右孩子在2n+2位置上，它的父节点在（n-1）/2上，而根节点是0的位置上。

为了维护这个特点，二叉堆在添加元素的时候，需要一个“上移”的动作，如下图所示

 

 

7、添加元素源码解析

    //添加一个元素
    public boolean add(E e) {
        return offer(e);
    }

    
    public boolean offer(E e) {
        if (e == null)
            throw new NullPointerException();
	//修改版本+1
        modCount++;
	//记录当前队列元素的个数
        int i = size;
	//如果当前元素个数大于等于队列底层数组的长度，则进行扩容
        if (i >= queue.length)
            grow(i + 1);
	//元素个数+1
        size = i + 1;
	//如果队列中没有元素，则将元素e直接添加到根
        if (i == 0)
            queue[0] = e;
	//否则调用siftUp方法，将元素添加到尾部，进行上移判断
        else
            siftUp(i, e);
        return true;
    }

　　

1） 扩容操作

    private void grow(int minCapacity) {
        int oldCapacity = queue.length;
        // 如果当前队列小于64，则扩容到2倍，否则扩容到1.5倍
        int newCapacity = oldCapacity + ((oldCapacity < 64) ?
                                         (oldCapacity + 2) :
                                         (oldCapacity >> 1));
        // 如果扩容后超出了int范围，则将newCapacity赋值为Integer.Max_VALUE
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
	//数组copy进行扩容
        queue = Arrays.copyOf(queue, newCapacity);
    }

　　

2）上移操作

    //上移，x表示新插入元素，k表示新插入元素在数组中的位置
    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;
	//k>0表示判断k不是根的情况下，也就是元素x有父节点。
        while (k > 0) {
	    //计算元素x的父节点位置(n-1)/2 
            int parent = (k - 1) >>> 1;
	    //取出x的父元素e
            Object e = queue[parent];
	    //如果新增的元素k比其父元素e大，则不需要“上移”，跳出循环结束
            if (key.compareTo((E) e) >= 0)
                break;
	    //x比父元素小，则需要进行“上移”
	    //交换元素x和父节点e的位置
            queue[k] = e;
	    //将新插入元素位置k指向父节点位置，进行下一次循环
            k = parent;

        }
	//找到新增元素x的合适位置k之后进行赋值
        queue[k] = key;
    }

　　总结： 二叉堆“上移”操作主要是不断的将新增的元素和父元素进行比较，比父节点小则上移。上移后再和父节点进行比较，直到根节点。

 

8、二叉堆删除原理

对应二叉堆出队操作，就是删除根元素，也就是最小的元素，找一个替代者移动到根位置，向对于被删除的元素来说就是“下移”

 

 

 

 

结合上面的图解，我们来说明一下二叉堆的出队过程:

     1. 将找出队尾的元素8，并将它在队尾位置上删除（图2）;

     2. 此时队尾元素8比根元素1的最小孩子3要大，所以将元素1下移，交换1和3的位置（图3）；

     3. 然后此时队尾元素8比元素1的最小孩子4要大，继续将1下移，交换1和4的位置（图4）；

     4. 然后此时根元素8比元素1的最小孩子9要小，不需要下移，直接将根元素8赋值给此时元素1的位置，1被覆盖则相当于删除（图5），结束。

 

参考：https://www.cnblogs.com/linghu-java/p/9467805.html