Java源碼閱讀-PriorityQueue

/**
     * Priority queue represented as a balanced binary heap: the two
     * children of queue[n] are queue[2*n+1] and queue[2*(n+1)].  The
     * priority queue is ordered by comparator, or by the elements'
     * natural ordering, if comparator is null: For each node n in the
     * heap and each descendant d of n, n <= d.  The element with the
     * lowest value is in queue[0], assuming the queue is nonempty.
     */
    private transient Object[] queue; // 一個數組隊列，用於存放元素

插入元素

/**
     * Inserts the specified element into this priority queue.
     *
     * @return {@code true} (as specified by {@link Queue#offer})
     * @throws ClassCastException if the specified element cannot be
     *         compared with elements currently in this priority queue
     *         according to the priority queue's ordering
     * @throws NullPointerException if the specified element is null
     */
    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;
    }

/**
     * Inserts item x at position k, maintaining heap invariant by
     * promoting x up the tree until it is greater than or equal to
     * its parent, or is the root.
     *
     * To simplify and speed up coercions and comparisons. the
     * Comparable and Comparator versions are separated into different
     * methods that are otherwise identical. (Similarly for siftDown.)
     *
     * @param k the position to fill
     * @param x the item to insert
     */
    private void siftUp(int k, E x) {
        if (comparator != null)
            siftUpUsingComparator(k, x);
        else
            siftUpComparable(k, x);
    }

    private void siftUpUsingComparator(int k, E x) { // 傳進來的k時剛插入的位置，隊列末尾
        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;
    }