java基础之：堆排序

　　最近做题目饱受打击，愈发觉得打好基础的重要性，于是乎，决心把基本的排序算法还有数组操作一一实现，目的在于
一方面能够得到对JAVA基础的巩固，另一面在实现的过程中发现不足。
　　今天所实现的堆排序（最大堆）算法，最小堆大同小异。然后基于最大堆实现最大优先队列，最大优先队列可应用于作
业调度，比如可将作业长度作为关键字值，实现最长作业优先；或者将作业优先权值作为关键字值，实现高优先权作业优先
执行等等。
最大堆排序算法结构如下图：

　　

 //:ThinkingInJava/com.mindview.fundamental/MaxHeap.java
 package com.mindview.fundamental;
 /**
  *
  * @Time 2014-6-17
  * @Descri MaxHeap.java 最大堆排序实现算法
  *             parent (i-1)/2
  *             left 2*i+1
  *             right 2*i+2
  * @author pattywgm
  *
  */
 public class MaxHeap {
     int a[];
     int a_heapsize;
     //接受数组
     public MaxHeap(int a[]) {
         this.a=a;
         a_heapsize=a.length;
     }
 
     //堆排序
     public void heapSort(){
         buildMaxHeap();
         for(int i=a.length-1;i>0;i--){
             //从大到小输出，实际数组顺序输出为从小到大
 //            System.out.print(a[0]+"  ");
             exchange(0, i);
             a_heapsize=a_heapsize-1;
             maxHeapIFY(0);//from top to bottom
         }
     }
 
     //创建堆
     public void buildMaxHeap(){
         //a[(a.length-1)/2] to a[0] is not leaf
         for(int i=(a.length/2-1);i>=0;i--){
             maxHeapIFY(i);
         }
     }
     //调整堆，以使其符合最大堆性质
     public void maxHeapIFY( int i) {
         int aLeft=2*i+1;//leftChild
         int aRight=2*i+2;//rightChild
         int largest;
         if(aLeft<a_heapsize && a[aLeft]>a[i])
             largest=aLeft;
         else
             largest=i;
         if(aRight<a_heapsize && a[aRight]>a[largest])
             largest=aRight;
         if(largest!=i){
             exchange(i,largest);
             //子树可能违反最大堆性质，继续调整
             maxHeapIFY(largest);
         }
 
     }
     //exchange A[i] with A[largest]
     public void exchange(int i, int largest) {
         int temp=a[i];
         a[i]=a[largest];
         a[largest]=temp;
 
     }
 }
 
 ///:~

　　其中buildMaxHeap()实现建立最大堆，HeapSort()方法首先调用该方法建立最大堆，然后获取堆顶元素即为最大元素，
将其与堆底最后一个元素交换后输出到数组中，此时得到新的堆大小，并通过maxHeapIFY()方法继续调整堆，以使堆能够
满足最大堆性质。循环迭代该过程，即可实现最大堆的排序，数组中最后保存的元素顺序是从小到大的。
最大优先队列算法结构图如下：

 //:ThinkingInJava/com.mindview.fundamental/MaxPriorityQueue.java
 package com.mindview.fundamental;
 /**
  *
  * @Time 2014-6-17
  * @Descri MaxPriorityQueue.java
  *            基于最大堆，实现最大优先队列，最大优先队列应用于作业调度
  *           可将作业长度作为关键字，进行比较
  * @author pattywgm
  *
  */
 public class MaxPriorityQueue {
     int task[];
     MaxHeap heap;
     public MaxPriorityQueue(int[] task) {
         this.task=task;
         heap=new MaxHeap(task);
         heap.buildMaxHeap();//创建最大堆
     }
     //获取最大关键字
     public int heapMaxiMum(){
         return task[0];
     }
     //去掉并返回最大关键字
     public int heapExtractMax(){
         if(heap.a_heapsize<1){
             System.out.println("Error:heap underflow");
             return -1;
         }
         else{
             int max=task[0];
             task[0]=task[heap.a_heapsize-1];
             heap.a_heapsize=heap.a_heapsize-1;
             heap.maxHeapIFY(0);
             return max;
         }
     }
     //在堆中插入元素x
     public void heapInsert(int x){
         task[heap.a_heapsize]=-1;
         System.out.println("insert: "+heap.a_heapsize);
         heap.a_heapsize=heap.a_heapsize+1;
         if(heap.a_heapsize>task.length){
             System.out.println("Error:array overflow");
             return;
         }
         else{
             heapIncreaseKey(heap.a_heapsize-1,x);
         }
     }
     //将元素x值增加到key
     public void heapIncreaseKey(int i,int key){
         if(task[i]>=key){
             System.out.println("new key is not bigger than current key");
             return;
         }
         else{
             task[i]=key;
             //parent: (i-1)/2
             while(i>0 && task[(i-1)/2]<task[i]){
                 heap.exchange(i, (i-1)/2);
                 i=(i-1)/2;
             }
         }
     }
 
     public void print(){
         for(int i=0;i<heap.a_heapsize;i++){
             System.out.print(task[i]+"  ");
         }
     }
 
 }
 
 ///:~

　　初始化调用MaxHeap类的buildMaxHeap()实现建立最大堆，即初始的最大优先队列。该最大优先队列支持以下操作：
　　　　1）heapMaxiMum():获取最大关键字值（依据最大堆性质，实际上只是获取堆顶元素）
　　　　2）heapExtractMax():去掉并返回最大关键字值，此时应注意重新调整堆（包括堆的大小和重新排列）
　　　　3）heapInsert(key):在现有队列中插入元素key,该操作与4）结合实现
　　　　4) heapIncreaseKey(i,key):将队列中指定位置处的值增加到key,注意值增加后堆性质的满足与否并做出相
　　　　应调整
　　映射到作业调度的问题，可将作业优先权值作为关键字值，1）或 2）操作获取当前作业队列中具有最高优先权的作业
进行调度， 2）操作更符合实际情况，在调度的同时更新队列；3）操作当有新的作业到来时将其插入优先权队列，并遵守
最大优先权最先执行的原则；4）操作在作业执行过程中，可能某个在优先权队列中的作业急需被调用，而其当前优先权却
不高，那么就需要提高其优先权，以使其能够被尽早调度。