Java堆排序算法

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

1. package heap;
3. /**
4.  * Heap sort operation.
5.  * This programm is based on the source of JDK Timer Class,
6.  * modified by Mo xuansheng.
7.  * Author Mo xuansheng
8.  * Date: 05/11/2008
9.  */
10. public class HeapOp {
11.     private PriorityQueue queue = new PriorityQueue();
12.     
13.     public HeapOp() {
14.         
15.     }
16.     public void insert(int a) {
17.         queue.add(a);
18.     }
19.     
20.     public int retrive() {
21.         int a =  queue.getMin();
22.         queue.removeMin();
23.         return a;
24.     }
25.     
26.     public boolean isQueueEmpty() {
27.         return queue.isEmpty();
28.     }
29.     class PriorityQueue {
30.         private int[] array = new int[128];
31.         
32.         private int size = 0;
33.         
34.         public PriorityQueue() {
35.             
36.         }
37.         
38.          int size() {
39.             return size;
40.         }
41.         
42.          boolean isEmpty() {
43.              return size == 0;
44.          }
45.                             
46.          void add(int a) {
47.              if (++size == array.length) {
48.                  int[] newarray = new int[2 * array.length];
49.                  System.arraycopy(array, 0, newarray, 0, size);
50.                  array = newarray;
51.              }
52.              array[size] = a;
53.              fixUp(size);
54.          }
55.          
56.          int getMin() {
57.              return array[1];
58.          }
59.          
60.          void removeMin() {
61.              array[1] = array[size];
62.              array[size--] = -1;
63.              fixDown(1);
64.          }
65.          
66.          void clear() {
67.              for (int i = 1; i < size; i++) 
68.                  array[i] = -1;
69.              size = 0;
70.          }
71.          
72.          /**
73.           * 将新增的数据在数组中进行排序，每增加一个数据Item，
74.           * 需要和它的父亲节点进行比较，如果数值大于父亲节点，
75.           * 则，证明改子树维持了堆序列；
76.           * 如果数值小于父节点，则与父节点交换，此时再次判断
77.           * 在新位置上的父节点之间的关系
78.           */
79.          private  void fixUp(int k) {
80.              while(k > 1) {
81.                  int j = k >> 1;
82.                  if (array[j] <= array[k])
83.                      break;
84.                  int tmp = array[j]; array[j] = array[k]; array[k] = tmp;
85.                  k = j;
86.              }
87.          }
88.          
89.          /**
90.           * 当从队列的头部移除最小值以后，将队末的数据Item放置到队首，
91.           * 然后进行排序。判断它与其子节点之间的大小关系，如果大于子节点，
92.           * 则与子节点进行交换，以此类推
93.           */
94.          private void fixDown(int k) {
95.              int j;
96.              while ((j = k <<1) <= size && j > 0) {
97.                  if (j < size && array[j] > array[j+1])
98.                      j++; // j indexes the smallest kid
99.                  if (array[k] <= array[j])
100.                      break;
101.                  int tmp = array[j]; array[j] = array[k]; array[k] = tmp;
102.                  k = j;
103.              }
104.          }
105.          
106.          void heapify() {
107.              for (int i = size/2; i >=1; i++)
108.                  fixDown(i);
109.          }
110.     }
111.     
112.     public static void main(String args[]) {
113.         HeapOp heap = new HeapOp();
114.         //insert the data reversely
115.         heap.insert(3);
116.         heap.insert(1);
117.         heap.insert(5);
118.         heap.insert(7);
119.         heap.insert(10);
120.         heap.insert(8);
121.         heap.insert(4);
122.         heap.insert(2);
123.         heap.insert(6);
124.         heap.insert(9);
125. //      for (int i =10 ;i >= 1; i--) {
126. //          heap.insert(i);
127. //      }
128.         
129.         //output the number orderly
130.         while(!heap.isQueueEmpty()) {
131.             System.out.println(heap.retrive());
132.         }
134.     }
135.     
136. }

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