堆排序（简单版和通行版本）

简单版：使用暴力建堆，初始为空堆，每个元素依次加入堆中
通行版：初始时是一个不符合定义的堆，从最后一个非叶结点开始调整堆。计算量比简单版少一半。

package com.cloudea.testjava;

public class Main {

    public static void swap(int[] nums, int a, int b){
        int t = nums[a];
        nums[a] = nums[b];
        nums[b] = t;
    }
    
    /**
     * 堆排序简单版本，暴力建堆
     * @param nums
     */
    public static void headSort(int[] nums){
        if(nums == null || nums.length < 2){
            return;
        }
        // 建堆
        for(int i = 0; i < nums.length; i++){
            // 让每个元素上浮
            int current = i;
            while(current != 0){
                int parent = (current - 1) / 2;
                if(nums[parent] < nums[current]){
                    swap(nums, parent, current);
                }
                current = parent;
            }
        }
        //从堆出依次取出元素
        for(int i = nums.length - 1; i >= 0; i--){
            swap(nums, 0, i);
            // 取完后令堆顶元素下沉
            int current = 0;
            int L = 1;
            int R = 2;
            while(L < i){ // 非叶子
                // 取最大的子元素， 默认是左子，如果右子存在且右子大，则取右子
                int bigChild = L;
                if(R < i && nums[L] < nums[R]){
                    bigChild = R;
                }
                // 如果最大子元素比当前结点的值大，则当前结点下沉
                if(nums[current] < nums[bigChild]){
                    swap(nums, current, bigChild);
                    current = bigChild;
                    L = bigChild * 2 + 1;
                    R = bigChild * 2 + 2;
                }else{
                    break;
                }
            }
        }
    }

    /**
     * 堆排序，通行版本
     * @param nums
     */
    public static void headSort2(int[] nums){
        if(nums == null || nums.length < 2){
            return;
        }
        // 建堆 (自底向上，从第一个非叶子结点开始调整，以下图为例，应该从结点3开始)
        /**
         *          0
         *        /   \
         *       1     2
         *      / \   /  \
         *     3   4  5   6
         *    /
         *   7
         */
        for(int i = nums.length / 2 - 1; i >= 0; i--){
            // 让每个下沉。（可以证明，当左右子树已经是堆的情况下，这种操作可以让当前子树成为堆）
            int current = i;
            int L = current * 2 + 1;
            int R = current * 2 + 2;
            while(L < nums.length){
                int bigChild = L;
                if(R < nums.length && nums[L] < nums[R]){
                    bigChild = R;
                }
                if(nums[current] < nums[bigChild]){
                    swap(nums, current, bigChild);
                    current = bigChild;
                    L = bigChild * 2 + 1;
                    R = bigChild * 2 + 2;
                }else{
                    break;
                }
            }
        }
        //从堆出依次取出元素
        for(int i = nums.length - 1; i >= 0; i--){
            swap(nums, 0, i);
            // 取完后令堆顶元素下沉
            int current = 0;
            int L = 1;
            int R = 2;
            while(L < i){ // 非叶子
                // 取最大的子元素， 默认是左子，如果右子存在且右子大，则取右子
                int bigChild = L;
                if(R < i && nums[L] < nums[R]){
                    bigChild = R;
                }
                // 如果最大子元素比当前结点的值大，则当前结点下沉
                if(nums[current] < nums[bigChild]){
                    swap(nums, current, bigChild);
                    current = bigChild;
                    L = bigChild * 2 + 1;
                    R = bigChild * 2 + 2;
                }else{
                    break;
                }
            }
        }
    }
    
    public static void main(String[] args) {
        int[] arr1 = new int[10];
        int[] arr2 = new int[10];
        for(int i = 0; i < arr1.length; i++){
            arr1[i] = (int) (Math.random() * 10);
            arr2[i] = arr1[i];
        }
        
        System.out.println("未排序：");
        for(int i = 0; i < arr1.length; i++){
            System.out.print(arr2[i] + " ");
        }
        System.out.println();
        headSort(arr1);
        headSort2(arr2);
    
        System.out.println("排序后：");
        for(int i = 0; i < arr1.length; i++){
            System.out.print(arr1[i] + " ");
        }

        System.out.println();
        for(int i = 0; i < arr2.length; i++){
            System.out.print(arr2[i] + " ");
        }

        
        System.out.println();

        for(int i = 0; i < arr2.length; i++){
            System.out.print(arr1[i] == arr2[i]);
            System.out.print(" ");
        }
    }
}

测试结果：