priorityqueue.java

drools 一个开放源码的规则引擎

        if ( size != 0 )
        {
            // percolate top element to it's place in tree
            if ( ascendingOrder )
            {
                percolateDownMinHeap( 1 );
            }
            else
            {
                percolateDownMaxHeap( 1 );
            }
        }

        return result;
    }

    // -----------------------------------------------------------------------
    /**
     * Tests if the buffer is at capacity.
     * 
     * @return <code>true</code> if buffer is full; <code>false</code>
     *         otherwise.
     */
    protected boolean isAtCapacity()
    {
        // +1 as element 0 is noop
        return elements.length == size + 1;
    }

    /**
     * Percolates element down heap from the position given by the index. <p/>
     * Assumes it is a minimum heap.
     * 
     * @param index
     *            the index for the element
     */
    protected void percolateDownMinHeap(final int index)
    {
        final Object element = elements[index];
        int hole = index;

        while ( (hole * 2) <= size )
        {
            int child = hole * 2;

            // if we have a right child and that child can not be percolated
            // up then move onto other child
            if ( child != size && compare( elements[child + 1],
                                           elements[child] ) < 0 )
            {
                child++;
            }

            // if we found resting place of bubble then terminate search
            if ( compare( elements[child],
                          element ) >= 0 )
            {
                break;
            }

            elements[hole] = elements[child];
            hole = child;
        }

        elements[hole] = element;
    }

    /**
     * Percolates element down heap from the position given by the index. <p/>
     * Assumes it is a maximum heap.
     * 
     * @param index
     *            the index of the element
     */
    protected void percolateDownMaxHeap(final int index)
    {
        final Object element = elements[index];
        int hole = index;

        while ( (hole * 2) <= size )
        {
            int child = hole * 2;

            // if we have a right child and that child can not be percolated
            // up then move onto other child
            if ( child != size && compare( elements[child + 1],
                                           elements[child] ) > 0 )
            {
                child++;
            }

            // if we found resting place of bubble then terminate search
            if ( compare( elements[child],
                          element ) <= 0 )
            {
                break;
            }

            elements[hole] = elements[child];
            hole = child;
        }

        elements[hole] = element;
    }

    /**
     * Percolates element up heap from the position given by the index. <p/>
     * Assumes it is a minimum heap.
     * 
     * @param index
     *            the index of the element to be percolated up
     */
    protected void percolateUpMinHeap(final int index)
    {
        int hole = index;
        Object element = elements[hole];
        while ( hole > 1 && compare( element,
                                     elements[hole / 2] ) < 0 )
        {
            // save element that is being pushed down
            // as the element "bubble" is percolated up
            final int next = hole / 2;
            elements[hole] = elements[next];
            hole = next;
        }
        elements[hole] = element;
    }

    /**
     * Percolates a new element up heap from the bottom. <p/>Assumes it is a
     * minimum heap.
     * 
     * @param element
     *            the element
     */
    protected void percolateUpMinHeap(final Object element)
    {
        elements[++size] = element;
        percolateUpMinHeap( size );
    }

    /**
     * Percolates element up heap from from the position given by the index.
     * <p/>Assume it is a maximum heap.
     * 
     * @param index
     *            the index of the element to be percolated up
     */
    protected void percolateUpMaxHeap(final int index)
    {
        int hole = index;
        Object element = elements[hole];

        while ( hole > 1 && compare( element,
                                     elements[hole / 2] ) > 0 )
        {
            // save element that is being pushed down
            // as the element "bubble" is percolated up
            final int next = hole / 2;
            elements[hole] = elements[next];
            hole = next;
        }

        elements[hole] = element;
    }

    /**
     * Percolates a new element up heap from the bottom. <p/>Assume it is a
     * maximum heap.
     * 
     * @param element
     *            the element
     */
    protected void percolateUpMaxHeap(final Object element)
    {
        elements[++size] = element;
        percolateUpMaxHeap( size );
    }

    /**
     * Compares two objects using the comparator if specified, or the natural
     * order otherwise.
     * 
     * @param a
     *            the first object
     * @param b
     *            the second object
     * @return -ve if a less than b, 0 if they are equal, +ve if a greater than
     *         b
     */
    protected int compare(Object a,
                          Object b)
    {
        if ( comparator != null )
        {
            return comparator.compare( a,
                                       b );
        }
        else
        {
            return ((Comparable) a).compareTo( b );
        }
    }

    /**
     * Increases the size of the heap to support additional elements
     */
    protected void grow()
    {
        final Object[] array = new Object[elements.length * 2];
        System.arraycopy( elements,
                          0,
                          array,
                          0,
                          elements.length );
        elements = array;
    }

    // -----------------------------------------------------------------------
    /**
     * Returns an iterator over this heap's elements.
     * 
     * @return an iterator over this heap's elements
     */
    public Iterator iterator()
    {
        return new Iterator( )
        {

            private int index = 1;

            private int lastReturnedIndex = -1;

            public boolean hasNext()
            {
                return index <= size;
            }

            public Object next()
            {
                if ( !hasNext( ) )
                {
                    throw new NoSuchElementException( );
                }
                lastReturnedIndex = index;
                index++;
                return elements[lastReturnedIndex];
            }

            public void remove()
            {
                if ( lastReturnedIndex == -1 )
                {
                    throw new IllegalStateException( );
                }
                elements[lastReturnedIndex] = elements[size];
                elements[size] = null;
                size--;
                if ( size != 0 && lastReturnedIndex <= size )
                {
                    int compareToParent = 0;
                    if ( lastReturnedIndex > 1 )
                    {
                        compareToParent = compare( elements[lastReturnedIndex],
                                                   elements[lastReturnedIndex / 2] );
                    }
                    if ( ascendingOrder )
                    {
                        if ( lastReturnedIndex > 1 && compareToParent < 0 )
                        {
                            percolateUpMinHeap( lastReturnedIndex );
                        }
                        else
                        {
                            percolateDownMinHeap( lastReturnedIndex );
                        }
                    }
                    else
                    { // max heap
                        if ( lastReturnedIndex > 1 && compareToParent > 0 )
                        {
                            percolateUpMaxHeap( lastReturnedIndex );
                        }
                        else
                        {
                            percolateDownMaxHeap( lastReturnedIndex );
                        }
                    }
                }
                index--;
                lastReturnedIndex = -1;
            }

        };
    }

    /**
     * Returns a string representation of this heap. The returned string is
     * similar to those produced by standard JDK collections.
     * 
     * @return a string representation of this heap
     */
    public String toString()
    {
        final StringBuffer sb = new StringBuffer( );

        sb.append( "[ " );

        for ( int i = 1; i < size + 1; i++ )
        {
            if ( i != 1 )
            {
                sb.append( ", " );
            }
            sb.append( elements[i] );
        }

        sb.append( " ]" );

        return sb.toString( );
    }

}