堆排序

public class HeapSort {

    public static void minHeap(double a[],int index, int k) {
        int MinIndex = index;
        int LeftIndex = 2*index;
        int RightIndex = 2*index+1;
        if(LeftIndex <= k && a[LeftIndex] < a[MinIndex]){
            MinIndex = LeftIndex;
        }
        if(RightIndex <= k && a[RightIndex] < a[MinIndex]){
            MinIndex = RightIndex;
        }

        double temp;
        if(MinIndex != index){
            temp = a[index];
            a[index] = a[MinIndex];
            a[MinIndex] = temp;
            minHeap(a,MinIndex,k);
        }
    }

    //建堆：将一个数组a[1-k]变成一个最小堆
    public static void buildMinHeap(double a[],int k){
        int i;
        //用容量为k的最小堆来存储最大的k个数
        for(i = k;i >= 1;i--){
            minHeap(a,i,k);
        }
    }

    public static void findMaxKNumber(double[] a, int k, double[] maxK) {
        HeapSort.buildMinHeap(a,k);
        for(int i = a.length - 1; i > k; i--){
            double temp;
            if(a[1] < a[i]){
                temp = a[i];
                a[i] = a[1];
                a[1] = temp;
                HeapSort.minHeap(a,1,k);
            }
        }
        for(int i = 1;i <= k;i++){
            maxK[i - 1] = a[i];
        }
    }


}

// heap[start...end] exclude heap[start] are satisfy the definition of heap.
// this function will adjust heap[start] to make heap as a minHeap.
public static void heapAdjust(double[] heap, int start, int end) {
    double temp = heap[start];
    for (int i = 2*start; i <= end; i*=2) {
        if (i < end && (heap[i] > heap[i + 1])) {
            i++;
        }
        if (temp < heap[i]) {
            break;
        }
        heap[start] = heap[i];
        start = i;
    }
    heap[start] = temp;
}

public static void heapSort(double[] heap) {
    for (int i = heap.length/2; i > 0; i--) {
        heapAdjust(heap, i, heap.length - 1);
    }
    for (int i = heap.length - 1; i > 1; i--) {
        double tmp = heap[1];
        heap[1] = heap[i];
        heap[i] = tmp;

        heapAdjust(heap, 1, i - 1);
    }
}

//建堆：将一个数组a[1-k]变成一个最小堆
public static void buildMinHeap(double a[],int k) {
    for (int i = k/2; i > 0; i--) {
        heapAdjust(a, i, k);
    }
}

public static void findMaxNNumber(double[] a, int n) {
    MinHeapSort.buildMinHeap(a,n);
    for (int i = n + 1; i < a.length; i++) {
        if (a[i] > a[1]) {
            double temp = a[i];
            a[i] = a[1];
            a[1] = temp;
            heapAdjust(a, 1, n);
        }
    }
    for (int i = n; i > 1; i--) {
        double tmp = a[1];
        a[1] = a[i];
        a[i] = tmp;

        heapAdjust(a, 1, i - 1);
    }
}