Java堆排序算法

前段时间在阅读java中定时器Timer类的时候，其中对于TimerTask的处理是按照Task的时间，通过优先级队列输出最近的执行时间，这个过程中采用了堆排序算法。将相关算法整理了一下。
package heap;

/**
* Heap sort operation.
* This programm is based on the source of JDK Timer Class,
* modified by Mo xuansheng.
* Author Mo xuansheng
* Date: 05/11/2008
*/
public class HeapOp {
private PriorityQueue queue = new PriorityQueue();

public HeapOp() {

}
public void insert(int a) {
queue.add(a);
}

public int retrive() {
int a = queue.getMin();
queue.removeMin();
return a;
}

public boolean isQueueEmpty() {
return queue.isEmpty();
}
class PriorityQueue {
private int[] array = new int[128];

private int size = 0;

public PriorityQueue() {

}

int size() {
return size;
}

boolean isEmpty() {
return size == 0;
}

void add(int a) {
if (++size == array.length) {
int[] newarray = new int[2 * array.length];
System.arraycopy(array, 0, newarray, 0, size);
array = newarray;
}
array[size] = a;
fixUp(size);
}

int getMin() {
return array[1];
}

void removeMin() {
array[1] = array[size];
array[size--] = -1;
fixDown(1);
}

void clear() {
for (int i = 1; i < size; i++)
array[i] = -1;
size = 0;
}

/**
* 将新增的数据在数组中进行排序，每增加一个数据Item，
* 需要和它的父亲节点进行比较，如果数值大于父亲节点，
* 则，证明改子树维持了堆序列；
* 如果数值小于父节点，则与父节点交换，此时再次判断
* 在新位置上的父节点之间的关系
*/
private void fixUp(int k) {
while(k > 1) {
int j = k >> 1;
if (array[j] <= array[k])
break;
int tmp = array[j]; array[j] = array[k]; array[k] = tmp;
k = j;
}
}

/**
* 当从队列的头部移除最小值以后，将队末的数据Item放置到队首，
* 然后进行排序。判断它与其子节点之间的大小关系，如果大于子节点，
* 则与子节点进行交换，以此类推
*/
private void fixDown(int k) {
int j;
while ((j = k <<1) <= size && j > 0) {
if (j < size && array[j] > array[j+1])
j++; // j indexes the smallest kid
if (array[k] <= array[j])
break;
int tmp = array[j]; array[j] = array[k]; array[k] = tmp;
k = j;
}
}

void heapify() {
for (int i = size/2; i >=1; i++)
fixDown(i);
}
}

public static void main(String args[]) {
HeapOp heap = new HeapOp();
//insert the data reversely
heap.insert(3);
heap.insert(1);
heap.insert(5);
heap.insert(7);
heap.insert(10);
heap.insert(8);
heap.insert(4);
heap.insert(2);
heap.insert(6);
heap.insert(9);
// for (int i =10 ;i >= 1; i--) {
// heap.insert(i);
// }

//output the number orderly
while(!heap.isQueueEmpty()) {
System.out.println(heap.retrive());
}

}

}

关于Timer类的分析，在写。。。