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

Posted 2020-10-17 三分自留地

优先队列（堆）的定义

堆（英语：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;    //数组表示堆中元素

 

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

 

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

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

元素插入

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

 

 

 

删除最小元

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

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

 

 1 private void percolateDown(int hole) {//下滤元素
 2         int child;
 3         T tmp=array[hole];
 4         for(;hole*2<=currentSize;hole=child) {
 5             child=hole*2;//孩子节点的下标
 6             if(child!=currentSize&&
 7                     array[child+1].compareTo(array[child])<0)//找出较小的孩子节点
 8                 child++;
 9             if(array[child].compareTo(tmp)<0)//逐层下滤
10                 array[hole]=array[child];//元素替换
11             else
12                 break;
13         }
14         array[hole]=tmp;
15 }

 

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

  1 // BinaryHeap class
  2 //
  3 // CONSTRUCTION: with optional capacity (that defaults to 100)
  4 //               or an array containing initial items
  5 //
  6 // ******************PUBLIC OPERATIONS*********************
  7 // void insert( x )       --> Insert x
  8 // Comparable deleteMin( )--> Return and remove smallest item
  9 // Comparable findMin( )  --> Return smallest item
 10 // boolean isEmpty( )     --> Return true if empty; else false
 11 // void makeEmpty( )      --> Remove all items
 12 // ******************ERRORS********************************
 13 // Throws UnderflowException as appropriate
 14 
 15 /**
 16  * Implements a binary heap.
 17  * Note that all "matching" is based on the compareTo method.
 18  * @author Mark Allen Weiss
 19  */
 20 public class BinaryHeap<AnyType extends Comparable<? super AnyType>>
 21 {
 22     /**
 23      * Construct the binary heap.
 24      */
 25     public BinaryHeap( )
 26     {
 27         this( DEFAULT_CAPACITY );
 28     }
 29 
 30     /**
 31      * Construct the binary heap.
 32      * @param capacity the capacity of the binary heap.
 33      */
 34     public BinaryHeap( int capacity )
 35     {
 36         currentSize = 0;
 37         array = (AnyType[]) new Comparable[ capacity + 1 ];
 38     }
 39     
 40     /**
 41      * Construct the binary heap given an array of items.
 42      */
 43     public BinaryHeap( AnyType [ ] items )
 44     {
 45             currentSize = items.length;
 46             array = (AnyType[]) new Comparable[ ( currentSize + 2 ) * 11 / 10 ];
 47 
 48             int i = 1;
 49             for( AnyType item : items )
 50                 array[ i++ ] = item;
 51             buildHeap( );
 52     }
 53 
 54     /**
 55      * Insert into the priority queue, maintaining heap order.
 56      * Duplicates are allowed.
 57      * @param x the item to insert.
 58      */
 59     public void insert( AnyType x )
 60     {
 61         if( currentSize == array.length - 1 )
 62             enlargeArray( array.length * 2 + 1 );
 63 
 64             // Percolate up
 65         int hole = ++currentSize;
 66         for( array[ 0 ] = x; x.compareTo( array[ hole / 2 ] ) < 0; hole /= 2 )
 67             array[ hole ] = array[ hole / 2 ];
 68         array[ hole ] = x;
 69     }
 70 
 71 
 72     private void enlargeArray( int newSize )
 73     {
 74             AnyType [] old = array;
 75             array = (AnyType []) new Comparable[ newSize ];
 76             for( int i = 0; i < old.length; i++ )
 77                 array[ i ] = old[ i ];        
 78     }
 79     
 80     /**
 81      * Find the smallest item in the priority queue.
 82      * @return the smallest item, or throw an UnderflowException if empty.
 83      */
 84     public AnyType findMin( )
 85     {
 86         if( isEmpty( ) )
 87             throw new UnderflowException( );
 88         return array[ 1 ];
 89     }
 90 
 91     /**
 92      * Remove the smallest item from the priority queue.
 93      * @return the smallest item, or throw an UnderflowException if empty.
 94      */
 95     public AnyType deleteMin( )
 96     {
 97         if( isEmpty( ) )
 98             throw new UnderflowException( );
 99 
100         AnyType minItem = findMin( );
101         array[ 1 ] = array[ currentSize-- ];
102         percolateDown( 1 );
103 
104         return minItem;
105     }
106 
107     /**
108      * Establish heap order property from an arbitrary
109      * arrangement of items. Runs in linear time.
110      */
111     private void buildHeap( )
112     {
113         for( int i = currentSize / 2; i > 0; i-- )
114             percolateDown( i );
115     }
116 
117     /**
118      * Test if the priority queue is logically empty.
119      * @return true if empty, false otherwise.
120      */
121     public boolean isEmpty( )
122     {
123         return currentSize == 0;
124     }
125 
126     /**
127      * Make the priority queue logically empty.
128      */
129     public void makeEmpty( )
130     {
131         currentSize = 0;
132     }
133 
134     private static final int DEFAULT_CAPACITY = 10;
135 
136     private int currentSize;      // Number of elements in heap
137     private AnyType [ ] array; // The heap array
138 
139     /**
140      * Internal method to percolate down in the heap.
141      * @param hole the index at which the percolate begins.
142      */
143     private void percolateDown( int hole )
144     {
145         int child;
146         AnyType tmp = array[ hole ];
147 
148         for( ; hole * 2 <= currentSize; hole = child )
149         {
150             child = hole * 2;
151             if( child != currentSize &&
152                     array[ child + 1 ].compareTo( array[ child ] ) < 0 )
153                 child++;
154             if( array[ child ].compareTo( tmp ) < 0 )
155                 array[ hole ] = array[ child ];
156             else
157                 break;
158         }
159         array[ hole ] = tmp;
160     }
161 
162         // Test program
163     public static void main( String [ ] args )
164     {
165         int numItems = 10000;
166         BinaryHeap<Integer> h = new BinaryHeap<>( );
167         int i = 37;
168 
169         for( i = 37; i != 0; i = ( i + 37 ) % numItems )
170             h.insert( i );
171         for( i = 1; i < numItems; i++ )
172             if( h.deleteMin( ) != i )
173                 System.out.println( "Oops! " + i );
174     }
175 }

View Code