十大排序之堆排序

1.  构建最大堆。
2. 将最大值和队尾交换移到最后。
3. 再次调整为最大堆，将最大值和队尾交换。
4. 直到一个元素是一个堆，数组有序。

public static void heapSort(int[]arr){
    if (arr == null || arr.length < 2){
        return;
    }
    // 自上而下构建最大堆
    int heapSize = arr.length;
    for (int i = 0; i< heapSize; i++){
        heapInsert(arr, i);
    }
    while (heapSize > 0){
        // 将最大值移动到队列尾部并遮蔽最大值
        swap(arr, 0, --heapSize);
        // 队尾写入队头，自上而下调整最大堆
        heapfy(arr, 0, heapSize);
    }
}
// 插入新的数，调整堆为最大堆
// 自下而上的调整
public static void heapInsert(int[]arr, int index){
    int parent = (index - 1) / 2;
    while (arr[index] > arr[parent]){
        // 子节点的值大于父节点
        swap(arr, index, parent);
        index = parent;
        parent = (index - 1) /2;
    }
}
// 某个数在index位置，向下移动保持最大堆
// 自上而下的调整
public static void heapfy(int[]arr, int index, int heapSize){
    int left = index * 2 + 1;
    //有子孩子就判断
    while (left < heapSize){
        // 左右子节点之间比较最大值
        int largest = (left + 1 < heapSize && arr[left] < arr [left +1])?  left + 1 : left;
        // 父子之间比较最大值
        largest = arr[largest] > arr[index] ? largest : index;
        // 父节点已经是最大值
        if (largest == index){
            break;
        }
        swap(arr, index, largest);
        index = largest;
        left = index * 2 + 1;
    }
}

无注释版

public static void heapSort(int[]arr){
    if (arr == null || arr.length < 2){
        return;
    }
    int heapSize = arr.length;
    for (int i = 0; i< heapSize; i++){
        heapInsert(arr, i);
    }
    while (heapSize > 0){
        swap(arr, 0, --heapSize);
        heapfy(arr, 0, heapSize);
    }
}
public static void heapInsert(int[]arr, int index){
    int parent = (index - 1) / 2;
    while (arr[index] > arr[parent]){
        swap(arr, index, parent);
        index = parent;
        parent = (index - 1) /2;
    }
}

public static void heapfy(int[]arr, int index, int heapSize){
    int left = index * 2 + 1;
    while (left < heapSize){
        int largest = (left + 1 < heapSize && arr[left] < arr [left +1])?  left + 1 : left;
        largest = arr[largest] > arr[index] ? largest : index;
        if (largest == index){
            break;
        }
        swap(arr, index, largest);
        index = largest;
        left = index * 2 + 1;
    }
}