1. 程式人生 > >基於堆的優先佇列和堆排序

基於堆的優先佇列和堆排序

  1.           public class MaxPQ<Key extends Comparable<key>>{
  2.                private Key[] pq;
  3.                private int N = 0;
  4.                pulbic MaxPQ(int maxN){
  5.                     //值儲存在pq[1...N]中,pq[0]不適用,所以陣列的長度為maxN+1
  6.                     pq = (Key[]) new Comparable[maxN+1];
  7.                }
  8.                public boolean isEmpty(){
  9.                     return N==0;
  10.                }
  11.                public int size(){
  12.                     return N;
  13.                }
  14.                public void insert(Key v){
  15.                     pq[++N] = v;
  16.                     swim(N);
  17.                }
  18.                public Key delMax(){
  19.                     Key max = pq[1];
  20.                     exch(q,N--);
  21.                     pq[N+1]=null;
  22.                     sink(1);
  23.                     return max;
  24.                }
  25.                //上浮
  26.                private void swim(int n){
  27.                     while(n>1&&less(n/2,n)){
  28.                          exch(n/2,n);
  29.                          n=n/2;
  30.                     }
  31.                }
  32.                //下沉
  33.                private void sink(int k){
  34.                     while(k*2<=N){
  35.                          int j = k*2;
  36.                          if(less(j,j+1)) j++;
  37.                          if(!less(k,j)) break;
  38.                          exch(k,j);
  39.                          k=j;
  40.                     }
  41.                }
  42.                private boolean less(int i,int j){
  43.                     //return pq[i]<pq[j]?true:false;
  44.                     return pq[i].compareTo(pq[j])<0;
  45.                }
  46.                private void exch(int i,int j){
  47.                     Comparable temp;
  48.                     temp = pq[i];
  49.                     pq[i] = pq[j];
  50.                     pq[j] = temp;
  51.                }
  52.           }