最大堆及堆排序的Java实现_world

package com.atguigu.me.algorithm.sort;

import java.util.concurrent.CancellationException;

public class PriorityQueue<Key extends Comparable<Key>> {
private Key[] pq;//基于堆的完全二叉树
private int N;//存储于pq[1..N]中，pq[0]没有使用

public PriorityQueue(int maxN){
pq = (Key[]) new Comparable[maxN+1];
}

public boolean isEmpty(){
return N==0;
}

public int size(){
return N;
}

public void insert(Key v){
pq[++N] = v ;
swim(N);
}

public Key delMax(){
Key max = pq[1];//从根节点得到最大元素
exch(1,N--);//将其和最后一个节点交换
pq[N+1] = null;//防止越界
sink(1);//恢复堆的有序性
return max;
}

//堆排序：将最大堆由上到下下沉  使其变为升序
public static void sort(Comparable[] a){
int N = a.length;
for(int k = N/2;k>=1;k--){
sink(a,k,N);
}
while(N>1){
exch(a,1,N-1);
sink(a,1,N);
}
}


public static void sink(Comparable[] a, int k, int n) {
while (2*k <= n){
int j = 2 * k;
if(j<n && less(a,j,j+1)){//对比2k+1和2k的大小，如果左边小于右边j就加1
j++;
}
if(less(a,j,k)){//将节点向下移动直到他的子节点都比它更小或是到达了堆的底部，停止循环
break;
}
exch(a,k,j);
k = j;//对于下次循环
}
}

public static void exch(Comparable[] a, int i, int j) {
Comparable temp = a[i];
a[i]= a[j];
a[j] = a[i];
}

public static boolean less(Comparable[] a,int i, int k) {
return a[i].compareTo(a[k]) < 0;
}

//上浮一层就将将k等于k/2(父节点)
public  void swim(int k) {
while(k>1 && less(k/2,k)){//节点不断向上移动直到遇到一个更大的的父节点
exch(k/2,k);
k = k/2;
}
}

//下沉一层就将k等于2k或2k+1
public void sink(int k){
while (2*k <= N){
int j = 2 * k;
if(j<N && less(j,j+1)){//对比2k+1和2k的大小，如果左边小于右边j就加1
j++;
}
if(less(j,k)){//将节点向下移动直到他的子节点都比它更小或是到达了堆的底部，停止循环
break;
}
exch(k,j);
k = j;//对于下次循环
}
}




public void exch(int i, int k) {
Key v = pq[i];
pq[i] = pq[k];
pq[k] = v;
}


public boolean less(int i, int k) {
return pq[i].compareTo(pq[k]) < 0;
}

public static void main(String[] args) {
PriorityQueue<Integer> pqs = new PriorityQueue<>(5);

pqs.insert(new Integer(5));
pqs.insert(new Integer(8));
pqs.insert(new Integer(6));
pqs.insert(new Integer(9));
pqs.insert(new Integer(1));

Comparable[] cs = new Comparable[5];
cs = pqs.pq;

for(int i = 0;i<6;i++){
System.out.print(cs[i]+"-->");
}
}

}