Queue队列API与源码分析优先级队列PriorityQueue实现原理

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

}

private static int hugeCapacity(int minCapacity) {

if (minCapacity < 0) // overflow

throw new OutOfMemoryError();

return (minCapacity > MAX_ARRAY_SIZE) ?

Integer.MAX_VALUE :

MAX_ARRAY_SIZE;

}

重点关注@2，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) { // @1

int parent = (k - 1) >>> 1; //@2

Object e = queue[parent];

if (comparator.compare(x, (E) e) >= 0) //@3

break;

queue[k] = e; // @4

k = parent; //@5

}

queue[k] = x; //@6

}

重点分析一下 siftUpUsingComparator 方法，比较器不为空。

首先，参数k的值为增加元素之前的 size 值，也就是，PriorityQueue 总是在先将节点放在内部数组元素的索引为 size 的位置，size 加一，然后找到 element[size] 的父节点，对比两者之间的大小关系，如果小于父节点，则交换两者的位置，继续像上找其父节点。直到父节点为空，索引<=0

代码@2，上文中也说过，PriorityQueue用数组来存储一棵完成二叉树，索引为n的左右子节点的索引分别为2n+1,2n+2( 2(n+1)),那已知子节点的索引为k,父节点的索引则为 看 (k -1) / 2 ,所以就不难理解 (k-1)>>>1。parent为父节点的索引。

代码@3，如果子节点的值大于父节点的值，由于满足最小堆的定义（父节点比两个子节点的值都要小），不需要调整树的结构，直接将元素x添加到数组索引代表的k位置。

代码@4，如果子节点的值小于父节点的值，则将父节点的值存入到k位置，设置k为parent，如果k的值小于等于0，则执行@6,否则继续找parent的父节点，再次比较父节点与x的大小。

2.2 public E poll() 方法详解

---

public E poll() {

if (size == 0)

return null;

int s = --size;

modCount++;

E result = (E) queue[0]; // @1

E x = (E) queue[s]; // @2

queue[s] = null; //@3

if (s != 0)

siftDown(0, x);

return result;

}

再重复一下poll方法的语义，如果队列为空，则返回null,否则移除队列中的第一个元素，并返回。

代码@1，返回队列中第一个元素，最小堆中，queue[0]代表根节点。

代码@2,获取数组中最后一个元素，该数组有个特点，如果索引size-1的元素肯定不为空，并且为该数组最后一个不为空的元素。数组中的元素是连续不为空，因为从算法角度来说，在添加元素的时候，总是首先在 queue[size-1]的位置添加元素，然后与该位置的父节点去比较，并且总是先添加左节点，然后添加右节点。从而保证数组元素是连续的；从完成二叉树的定义中也规定，只有最后两层的节点的度少于二，也保证了数组元素不会出现不连续，所谓的不连续是不允许 queue[0],queue[2]不为空，但queue[1]为空的情况。

代码@3，将queue最后一个节点设置为空，然后用该节点与根节点去做比较，将该树中最小值设置为新的根节点，达到将旧根节点移除的目的。具体请看如下代码。

/**

• Inserts item x at position k, maintaining heap invariant by

• demoting x down the tree repeatedly until it is less than or

• equal to its children or is a leaf.

• @param k the position to fill

• @param x the item to insert

*/

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; // @1

while (k < half) { //@2

int child = (k << 1) + 1; //@3

Object c = queue[child]; //@4

int right = child + 1; //@5

if (right < size && //@6

comparator.compare((E) c, (E) queue[right]) > 0) //@7

c = queue[child = right];

if (comparator.compare(x, (E) c) <= 0) //@8

break;

queue[k] = c;

k = child;

}

queue[k] = x; //@9

}

代码 siftDownUsingComparator 是从根节点开始重构该树，使之维持最下堆特性。入参中的k为0，x为原先最后一个元素。该方法的目的是要移除头部节点，然后找到最新的头节点。实现方法是，用指定的位置k节点开始下沉，找到最小节点成为新的头部节点，如果k节点没有子节点，直接将位置k的节点设置为x,原k节点的数据被删除；如果k有子节点，然后找到k的两个子节点中最小的那个节点位置(child为最小的节点)，如果K的最小的子节点比x的大的话，说明x符合成为K两个子节点的父节点，故直接将x替换原来的k即可，否则将最小的子节点替换K，然后从k=child，重复上述操作。

代码@1，因为最后一个元素为size-1,根据该数组的特性，0-size/2的节点有子节点,不包括size/2,[0,half)为所有的根节点。故代码@2的循环条件为k>half。

代码@3，k的左孩子的索引。

代码@4，k的左孩子节点的值。

代码@5，k的右孩子。

代码@5，@7，如果右孩子不为空，则取，左右两个孩子中比较小的值，用来比较。

代码@7，如果x的值比待替换的根节点的两个孩子节点都小，直接将X替换为根节点即可，运行代码@9。

否则，用根节点下两个子节点中最小值替换一下根节点。然后从child位置重复上面的计算，确保新的子数也符合最小堆的定义，while循环结束有如下两种情况，1：k>=half，说明位置k已经是叶子节点了，故需要跳出运行；如果x的值比父节点的两个子节点都小，跳出循环。将下标k处的值设置为x。

2.3 public boolean remove(Object o)

---

public boolean remove(Object o) {

int i = indexOf(o);

if (i == -1)

return false;

else {

removeAt(i); // @1

return true;

}

}

private E removeAt(int i) {

assert i >= 0 && i < size;

modCount++;

int s = --size;

if (s == i) // removed last element

queue[i] = null;

else { // @2

E moved = (E) queue[s]; //@3

queue[s] = null; //@4

siftDown(i, moved); //@5

if (queue[i] == moved) { //@6

siftUp(i, moved); //@7

if (queue[i] != moved)

return moved;

}

}

return null;

}

该方法的实现思想是首先在queue数组中找到该值，如果找不到，直接返回-1，是队列最后一个元素，直接从队列中删除即可，如果是队列中间的元素，删除操作就没那么简单，删除元素后，要保证数组元素的连续性（其实就是要保证删除后的树满足最小堆的定义）

代码@3、@4，先用临时变量moved保存队列的最后一个元素，然后将队列最后一个元素删除（设置为空）

代码@5，删除下标为i的元素，然后用moved元素来填充一个空位。

siftDown执行完毕后，moved元素所在的位置有如下几种可能：

• moved放在下标为i的地方，这里包含两种情况，1）位置为i的元素为叶子节点。2）如果move元素比i的两个

子元素小。

• moved放在下标大于i的地方，如果moved元素比i的最小的子节点大，此时用最小的子节点替换父节点。i的           索引设置为原i最小节点的索引，从该索引继续执行siftDown过程。

如果moved放在下标大于i的地方，本次删除成功结束。

如果moved位置放在i的位置，此时，需要上浮，确定moved是否比父节点大，如果比父节点小，则不符合最小堆定义，通过上浮调整。siftUp 方法不会删除元素，但 siftDown 方法会删除一个元素。

接下来，就是从待移除的位置 i 处开始下沉，我们知道 siftDown(int k,E x)方法，可以说就是移除k位置的元素，然后将加入到以k为父节点的树中（保持最小堆特性），但要是位置为k的地方是叶子节点呢？siftDown的做法是直接将x放入到k的位置。但这样会不会影响最小堆特性呢，答案是可能的，也就有了代码@6的判断，如果queue[i] == moved,说明此时k是叶子节点，，应该从索引为k向上升，判断该节点与父节点的关系，所以调用siftUp(int i, E x)方法，上浮，确保维持最小堆特性。在这里，我还想再啰嗦一下，重温一下siftUp的实现逻辑：如果i<=0，直接将x放入到队列索引为i的位置。如何大于0，则找到该节点的父节点，然后比较父节点与x的大小关系，如果x大于根节点，则直接将x放入到下标为i的地方，否则，需要将父节点放入位置i上，然后继续k=parent。

提问：PriorityQueue removeAt 返回值，是被移除的元素吗？

2.4 public Iterator iterator() 迭代器

---

首先，迭代器，既然PriorityQueue内部是一个数组queue[],那迭代器，直接遍历该数组就好了，是的，但迭代器与for(int i =0; i < size; i++)这中遍历方法，还有一个特殊的是，迭代器支持将当前迭代的元素删除，也就是remove方法。我们也知道，移除一个元素后，要重新调整结构，保证删除一元素后继续保持最小堆的特性。从上文中我们知道，从0-size-1直接删除一个元素，通常的做法，是先将尾部节点（移除队列，将size减一，然后将queue[size]的元素用临时变量保存，然后将queue[size]=null）,用该节点与要删除的元素进行对比，替换，再重构树特性。

所以，Itr类的设计，就是基于上述的考虑。

private final class Itr implements Iterator {

/**

• Index (into queue array 需要zi料+ 绿色徽【vip1024b】

) of element to be returned by

最后的话

无论是哪家公司，都很重视Spring框架技术，重视基础，所以千万别小看任何知识。面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。
同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，好了希望这篇文章对大家有帮助！

部分截图：

后将queue[size]的元素用临时变量保存，然后将queue[size]=null）,用该节点与要删除的元素进行对比，替换，再重构树特性。

所以，Itr类的设计，就是基于上述的考虑。

private final class Itr implements Iterator {

/**

• Index (into queue array 需要zi料+ 绿色徽【vip1024b】

) of element to be returned by

最后的话

无论是哪家公司，都很重视Spring框架技术，重视基础，所以千万别小看任何知识。面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。
同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，好了希望这篇文章对大家有帮助！

部分截图：
[外链图片转存中…(img-J6wvutyc-1710364408683)]