Queue佇列API與原始碼分析優先順序佇列PriorityQueue實現原理
阿新 • • 發佈：2019-01-22
程式碼@1,擴容，比較簡單，下面直接將程式碼copy出來，瀏覽一下即可：public boolean offer(E e) { if (e == null) throw new NullPointerException(); modCount++; int i = size; if (i >= queue.length) grow(i + 1); //@1 容量擴容 size = i + 1; if (i == 0) queue[0] = e; else siftUp(i, e); // @2 return true; }
/** * Increases the capacity of the array. * * @param minCapacity the desired minimum capacity */ 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); } private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) // overflow throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; }
重點分析一下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，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 }
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;
}/**
* 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
}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;
}private final class Itr implements Iterator<E> {
/**
* Index (into queue array) of element to be returned by
* subsequent call to next.
*/
private int cursor = 0; //@1
/**
* Index of element returned by most recent call to next,
* unless that element came from the forgetMeNot list.
* Set to -1 if element is deleted by a call to remove.
*/
private int lastRet = -1; //@2
/**
* A queue of elements that were moved from the unvisited portion of
* the heap into the visited portion as a result of "unlucky" element
* removals during the iteration. (Unlucky element removals are those
* that require a siftup instead of a siftdown.) We must visit all of
* the elements in this list to complete the iteration. We do this
* after we've completed the "normal" iteration.
*
* We expect that most iterations, even those involving removals,
* will not need to store elements in this field.
*/
private ArrayDeque<E> forgetMeNot = null; //@3
/**
* Element returned by the most recent call to next iff that
* element was drawn from the forgetMeNot list.
*/
private E lastRetElt = null; //@4
/**
* The modCount value that the iterator believes that the backing
* Queue should have. If this expectation is violated, the iterator
* has detected concurrent modification.
*/
private int expectedModCount = modCount;
public boolean hasNext() { //@5
return cursor < size ||
(forgetMeNot != null && !forgetMeNot.isEmpty());
}
public E next() {
if (expectedModCount != modCount)
throw new ConcurrentModificationException();
if (cursor < size)
return (E) queue[lastRet = cursor++];
if (forgetMeNot != null) {
lastRet = -1;
lastRetElt = forgetMeNot.poll();
if (lastRetElt != null)
return lastRetElt;
}
throw new NoSuchElementException();
}
public void remove() {
if (expectedModCount != modCount)
throw new ConcurrentModificationException();
if (lastRet != -1) {
E moved = PriorityQueue.this.removeAt(lastRet);
lastRet = -1;
if (moved == null)
cursor--;
else {
if (forgetMeNot == null)
forgetMeNot = new ArrayDeque<>();
forgetMeNot.add(moved);
}
} else if (lastRetElt != null) {
PriorityQueue.this.removeEq(lastRetElt);
lastRetElt = null;
} else {
throw new IllegalStateException();
}
expectedModCount = modCount;
}
}