解決問題：
TopK問題是指從大量數據（源數據）中獲取最大（或最小）的K個數據。

package com.lhcis.bond.business.constant;

public class HeapSortFinal {

    public static void main(String[] args) {
        int[] array = { 19, 38, 7, 36, 5, 5, 3, 2, 1, 0, 56 };

        System.out.println("排序前:");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + ",");
        }

        System.out.println();
        System.out.println("分割線---------------");

        heapSort(array);

        System.out.println("排序後:");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + ",");
        }
    }

    public static void heapSort(int[] array) {
        if (array == null || array.length == 1)
            return;

        buildMaxHeap(array); // 第一次排序，構建最大堆，只保證了堆頂元素是數組裏最大的

        for (int i = array.length - 1; i >= 1; i--) {
            // 這個是什麽意思呢？，經過上面的一些列操作，目前array[0]是當前數組裏最大的元素，需要和末尾的元素交換
            // 然後，拿出最大的元素
            swap(array, 0, i);

            // 交換完後，下次遍歷的時候，就應該跳過最後一個元素，也就是最大的那個值，然後開始重新構建最大堆
            // 堆的大小就減去1，然後從0的位置開始最大堆
//            maxHeap(array, i, 0);
            minHeap(array, i, 0);
        }
    }

    // 構建堆
    public static void buildMaxHeap(int[] array) {
        if (array == null || array.length == 1)
            return;

        // 堆的公式就是 int root = 2*i, int left = 2*i+1, int right = 2*i+2;
        int cursor = array.length / 2;
        for (int i = cursor; i >= 0; i--) { // 這樣for循環下，就可以第一次排序完成
//            maxHeap(array, array.length, i);
            minHeap(array, array.length, i);
        }
    }

    // 最大堆
    public static void maxHeap(int[] array, int heapSieze, int index) {
        int left = index * 2 + 1; // 左子節點
        int right = index * 2 + 2; // 右子節點
        int maxValue = index; // 暫時定在Index的位置就是最大值

        // 如果左子節點的值，比當前最大的值大，就把最大值的位置換成左子節點的位置
        if (left < heapSieze && array[left] > array[maxValue]) {
            maxValue = left;
        }

        // 如果右子節點的值，比當前最大的值大，就把最大值的位置換成右子節點的位置
        if (right < heapSieze && array[right] > array[maxValue]) {
            maxValue = right;
        }

        // 如果不相等，說明啊，這個子節點的值有比自己大的，位置發生了交換了位置
        if (maxValue != index) {
            swap(array, index, maxValue); // 就要交換位置元素

            // 交換完位置後還需要判斷子節點是否打破了最大堆的性質。最大堆性質：兩個子節點都比父節點小。
            maxHeap(array, heapSieze, maxValue);
        }
    }

    // 最小堆
    public static void minHeap(int[] array, int heapSieze, int index) {
        int left = index * 2 + 1; // 左子節點
        int right = index * 2 + 2; // 右子節點
        int maxValue = index; // 暫時定在Index的位置就是最小值

        // 如果左子節點的值，比當前最小的值小，就把最小值的位置換成左子節點的位置
        if (left < heapSieze && array[left] < array[maxValue]) {
            maxValue = left;
        }

        //  如果右子節點的值，比當前最小的值小，就把最小值的位置換成左子節點的位置
        if (right < heapSieze && array[right] < array[maxValue]) {
            maxValue = right;
        }

        // 如果不相等，說明啊，這個子節點的值有比自己小的，位置發生了交換了位置
        if (maxValue != index) {
            swap(array, index, maxValue); // 就要交換位置元素

            // 交換完位置後還需要判斷子節點是否打破了最小堆的性質。最小性質：兩個子節點都比父節點大。
            minHeap(array, heapSieze, maxValue);
        }
    }

    // 數組元素交換
    public static void swap(int[] array, int index1, int index2) {
        int temp = array[index1];
        array[index1] = array[index2];
        array[index2] = temp;
    }

}
 

堆排序 最大堆 最小堆 Java實現