JAVA数据结构--优先队列（堆实现）

优先队列（堆）的定义

堆（英语：Heap）是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。在队列中，调度程序反复提取队列中第一个作业并运行，因为实际情况中某些时间较短的任务将等待很长时间才能结束，或者某些不短小，但具有重要性的作业，同样应当具有优先权。堆即为解决此类问题设计的一种数据结构。

我个人比较通俗的理解就是比如我们平常下载视频看，我们打算下载两部视频，一部2G，一部只有200M。优先队列的思想就是先下载那部体积较小的视频，这样也比较合理，可以下完200M后看的同时再下2G的视频。

堆是一颗被完全填满的二叉树，唯一可能的例外是在最底层。所以堆具有两个性质——堆序性和结构性。一个高为h的完全二叉树有2^h或2^h-1个节点，并且堆中每一个节点X的父亲的值小于或等于X中的关键字，所以堆的最小值总可以在根中找到。

堆的构造实现

private static final int DEFAULT_CAPACITY=10;//定义堆的大小
private int currentSize;//当前实际堆的大小
private T [] array;    //数组表示堆中元素

public BinaryHeap(int capacity) {//初始化堆数组
        currentSize=0;
        array=(T[])new Comparable[capacity+1];
}
public BinaryHeap(T[] items) {
        currentSize=items.length;
        array=(T[])new Comparable[(currentSize+2)*11/10];
        
        int i=1;
        for(T item:items)
            array[i++]=item;//堆数组赋值
        buildHeap();
}

private void buildHeap() {
    for(int i=currentSize/2;i>0;i--)//逐层下滤
        percolateDown(i);
}

注意！用数组实现堆时，元素的下标是从1开始，不是从0开始。原因是因为当插入的元素是比堆顶还小的元素时，我们不需要对堆做任何操作即可把堆冒出。

元素插入

public void insert(T x) {
        if(currentSize==array.length-1)
            enlargeArray(array.length*2+1);//堆扩容
        int hole=++currentSize;    //空穴表示的数组下标
        /*
         * hole/2是当前空穴的父节点的数组下标，如果x比父节点的元素小，则父节点元素下沉，空穴上冒
         * */
        for(array[0]=x;x.compareTo(array[hole/2])<0;hole/=2)
            array[hole]=array[hole/2];    //元素交换
        array[hole]=x;
}

 

删除最小元

　删除最小元基本的思想是将最小元置为空穴，再将堆的最后一个元素放入其中，则此时的堆是不合法的，我们需要做的就是将此时的堆顶元素下沉到合适的位置。

public T deleteMin() throws Exception {
        if(isEmpty())
            throw new Exception();
        T minItem=findMin();//获取最小元
        array[1]=array[currentSize--];//取出最后一个元素
        percolateDown(1);//元素下滤
        return minItem;
}

private void percolateDown(int hole) {//下滤元素
        int child;
        T tmp=array[hole];
        for(;hole*2<=currentSize;hole=child) {
            child=hole*2;//孩子节点的下标
            if(child!=currentSize&&
                    array[child+1].compareTo(array[child])<0)//找出较小的孩子节点
                child++;
            if(array[child].compareTo(tmp)<0)//逐层下滤
                array[hole]=array[child];//元素替换
            else
                break;
        }
        array[hole]=tmp;
}

 

全部代码实现（数据结构与算法分析中的demo）

// BinaryHeap class
//
// CONSTRUCTION: with optional capacity (that defaults to 100)
//               or an array containing initial items
//
// ******************PUBLIC OPERATIONS*********************
// void insert( x )       --> Insert x
// Comparable deleteMin( )--> Return and remove smallest item
// Comparable findMin( )  --> Return smallest item
// boolean isEmpty( )     --> Return true if empty; else false
// void makeEmpty( )      --> Remove all items
// ******************ERRORS********************************
// Throws UnderflowException as appropriate

/**
 * Implements a binary heap.
 * Note that all "matching" is based on the compareTo method.
 * @author Mark Allen Weiss
 */
public class BinaryHeap<AnyType extends Comparable<? super AnyType>>
{
    /**
     * Construct the binary heap.
     */
    public BinaryHeap( )
    {
        this( DEFAULT_CAPACITY );
    }

    /**
     * Construct the binary heap.
     * @param capacity the capacity of the binary heap.
     */
    public BinaryHeap( int capacity )
    {
        currentSize = 0;
        array = (AnyType[]) new Comparable[ capacity + 1 ];
    }
    
    /**
     * Construct the binary heap given an array of items.
     */
    public BinaryHeap( AnyType [ ] items )
    {
            currentSize = items.length;
            array = (AnyType[]) new Comparable[ ( currentSize + 2 ) * 11 / 10 ];

            int i = 1;
            for( AnyType item : items )
                array[ i++ ] = item;
            buildHeap( );
    }

    /**
     * Insert into the priority queue, maintaining heap order.
     * Duplicates are allowed.
     * @param x the item to insert.
     */
    public void insert( AnyType x )
    {
        if( currentSize == array.length - 1 )
            enlargeArray( array.length * 2 + 1 );

            // Percolate up
        int hole = ++currentSize;
        for( array[ 0 ] = x; x.compareTo( array[ hole / 2 ] ) < 0; hole /= 2 )
            array[ hole ] = array[ hole / 2 ];
        array[ hole ] = x;
    }


    private void enlargeArray( int newSize )
    {
            AnyType [] old = array;
            array = (AnyType []) new Comparable[ newSize ];
            for( int i = 0; i < old.length; i++ )
                array[ i ] = old[ i ];        
    }
    
    /**
     * Find the smallest item in the priority queue.
     * @return the smallest item, or throw an UnderflowException if empty.
     */
    public AnyType findMin( )
    {
        if( isEmpty( ) )
            throw new UnderflowException( );
        return array[ 1 ];
    }

    /**
     * Remove the smallest item from the priority queue.
     * @return the smallest item, or throw an UnderflowException if empty.
     */
    public AnyType deleteMin( )
    {
        if( isEmpty( ) )
            throw new UnderflowException( );

        AnyType minItem = findMin( );
        array[ 1 ] = array[ currentSize-- ];
        percolateDown( 1 );

        return minItem;
    }

    /**
     * Establish heap order property from an arbitrary
     * arrangement of items. Runs in linear time.
     */
    private void buildHeap( )
    {
        for( int i = currentSize / 2; i > 0; i-- )
            percolateDown( i );
    }

    /**
     * Test if the priority queue is logically empty.
     * @return true if empty, false otherwise.
     */
    public boolean isEmpty( )
    {
        return currentSize == 0;
    }

    /**
     * Make the priority queue logically empty.
     */
    public void makeEmpty( )
    {
        currentSize = 0;
    }

    private static final int DEFAULT_CAPACITY = 10;

    private int currentSize;      // Number of elements in heap
    private AnyType [ ] array; // The heap array

    /**
     * Internal method to percolate down in the heap.
     * @param hole the index at which the percolate begins.
     */
    private void percolateDown( int hole )
    {
        int child;
        AnyType tmp = array[ hole ];

        for( ; hole * 2 <= currentSize; hole = child )
        {
            child = hole * 2;
            if( child != currentSize &&
                    array[ child + 1 ].compareTo( array[ child ] ) < 0 )
                child++;
            if( array[ child ].compareTo( tmp ) < 0 )
                array[ hole ] = array[ child ];
            else
                break;
        }
        array[ hole ] = tmp;
    }

        // Test program
    public static void main( String [ ] args )
    {
        int numItems = 10000;
        BinaryHeap<Integer> h = new BinaryHeap<>( );
        int i = 37;

        for( i = 37; i != 0; i = ( i + 37 ) % numItems )
            h.insert( i );
        for( i = 1; i < numItems; i++ )
            if( h.deleteMin( ) != i )
                System.out.println( "Oops! " + i );
    }
}