简单排序算法实现——堆排序

public class HeapSort{
private static int heapSize;

private static int indexOfLeft(int root){
return (2*root+1);
}

private static int indexOfRight(int root){
return 2*(root+1);
}

private static int indexOfParent(int root){
return (root-1)/2;
}

//This method will examine node at position i and its two childs.
//If i is smaller than one of its child, it will adjust it to maintain it as
//a max heap
private static <AnyType extends Comparable<? super AnyType>>
void MAX_HEAPIFY(AnyType[] a, int i){
int l=indexOfLeft(i);
int r=indexOfRight(i);
int indexOfMax;

//Condition l,r<=heapSize ensures that operation on leaf nodes will be tolerated.
if(l<=heapSize-1&&a[l].compareTo(a[i])>0) indexOfMax=l;
else indexOfMax=i; //If max==a[i], no operation at last;

if(r<=heapSize-1&&a[r].compareTo(a[indexOfMax])>0)
indexOfMax=r;

if(indexOfMax!=i){
AnyType temp=a[i];
a[i]=a[indexOfMax];
a[indexOfMax]=temp;

MAX_HEAPIFY(a, indexOfMax);
}

}

private static <AnyType extends Comparable<? super AnyType>>
void BUILD_MAX_HEAP(AnyType[] a){
heapSize=a.length;
for(int i=a.length/2-1;i>=0;i--){
MAX_HEAPIFY(a,i);
}
}

private static <AnyType extends Comparable<? super AnyType>>
void HeapSortOnMaxHeap(AnyType[] a){
AnyType temp;
for(int i=a.length-1;i>=1;i--){
temp=a[0];
a[0]=a[i];
a[i]=temp;

heapSize--;

MAX_HEAPIFY(a,0);
}
}

public static <AnyType extends Comparable<? super AnyType>>
void HeapSort(AnyType[] a){
BUILD_MAX_HEAP(a);
HeapSortOnMaxHeap(a);

}

public static void main(String[] args){
System.out.println("Heap Sort:");

Integer[] elements={3,4,1,8,10,2,0,6,5};

System.out.print("Original elements: ");
for(int i=0;i<elements.length;i++) System.out.print(elements[i]+" ");
System.out.println();

HeapSort(elements);

System.out.print("After sorting: ");
for(int i=0;i<elements.length;i++) System.out.print(elements[i]+" ");
System.out.println();
}

}