代碼如下：

public class HeapSort {
    public static void heapSort(DataWrap[] data)
    {
        System.out.println("開始排序");
        int length = data.length;
        //循環建堆
        for(int i = 0;i < length-1; i++)
        {
            //建堆
            buiilMaxdHeap(data , length-1-i);
            //交換堆訂和最後一個元素
 

            swap(data , 0, length-1-i);
            System.out.println(java.util.Arrays.toString(data));
        }
    }
    //交換data數組中i和j兩處索引的元素
    private static void swap(DataWrap[] data, int i, int j) {
        DataWrap tmp = data[i];
        data[i] = data[j];
        data[j] = tmp;
        
    }
    
 
//對data數組從0到lastindex建最大堆
    private static void buiilMaxdHeap(DataWrap[] data, int lastindex) {
        //從lastindex處節點（最後一個節點）的父節點開始
        for(int i = (lastindex -1)/2;i >= 0;i--)
        {
            //k保存當前正在判斷的節點
            int k = i;
            //如果當前k節點的子節點存在
            while(k * 2+1 <= lastindex)
            {
                
 
//k節點的左子節點的索引
                int biggerIndex = 2*k+1;
                //如果biggerIndex小於lastindex，即biggerindex＋1
                if(biggerIndex < lastindex)
                {
                    //如果右子節點的值較大
                    if(data[biggerIndex].compareTo(data[biggerIndex+1]) < 0)
                    {
                        //biggerIndex總是記錄較大子節點的索引
                        biggerIndex++;
                    }
                }
                //如果k節點的值小於較大字節點的值
                if(data[k].compareTo(data[biggerIndex]) < 0)
                {
                    //交換它們
                    swap(data, k, biggerIndex);
                    //將biggerIndex賦給k，開始while循環的下一次的循環
                    k = biggerIndex;
                }
                else
                {
                    break;
                }
            }
        }
    }
    public static void main(String[] args) {
        DataWrap [] data = {
                new DataWrap(21, ""),
                new DataWrap(30, ""),
                new DataWrap(49, ""),
                new DataWrap(30, ""),
                new DataWrap(21, ""),
                new DataWrap(16, ""),
                new DataWrap(9, "")
        };
        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
        heapSort(data);
        System.out.println("排序之後：\n" + java.util.Arrays.toString(data));
    }
}

說明：

上面堆排序的關鍵在於buildMaxHeap()方法。該方法用於對data數組從0到lastindex索引範圍內的元素建大頂堆，這樣就選擇出數組索引從0到lastindex範圍內的最大元素。采用循環不斷重復上面過程即可完成堆排序。

對於堆排序算法而言，假設有n項數據，需要進行n-1次建堆，每次建堆本身耗時為log2n，則其時間效率為O(nlog2n)。堆排序的空間效率很高，它只需要一個附加的程序單元用於交換，其空間效率為O(1)。

java堆排序實現