排序算法：堆排序Java实现，以及用PriorityQueue实现大顶堆的方法。

堆排序

• 时间复杂度 O(n logn)
• 稳定性：不稳定

1. 一般升序使用大顶堆，堆顶元素是最大值，与最末位元素交换，然后对前n-1个元素重新做堆排序。
2. 降序用最小堆

• Java中可以使用PriorityQueue实现堆排序，PriorityQueue本身实现的是小顶堆，可以用lambda表达式写成大顶堆

//PriorityQueue实现大顶堆
PriorityQueue<Integer> queue = new PriorityQueue<Integer>(new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
           return o2-o1;
    }
});

/**
 * 堆排序
 * 时间复杂度O(nlogn)
 * 稳定性:不稳定
 */
import java.util.Arrays;
//自顶向下的堆有序化
public class MyHeapSort {
    public static void main(String[] args) {
        int[] arr = {4, 5, 6, 7, 2, 8, 2, 3, 4};
        int[] arr2 = arr.clone();
        new MyHeapSort().heapSort(arr);
        System.out.println(Arrays.toString(arr));
        new MyHeapSort().smallHeapSort(arr2);
        System.out.println(Arrays.toString(arr2));
    }
	//大顶堆排序，升序排列
    public void heapSort(int[] arr) {
        for (int i = arr.length / 2 - 1; i >= 0; i--)
            adjustHeap(arr, arr.length, i);

        for (int j = arr.length - 1; j > 0; j--) {
            int tmp = arr[j];
            arr[j] = arr[0];
            arr[0] = tmp;
            adjustHeap(arr, j, 0);

        }
    }

    /**
     * 大顶堆
     */
    private void adjustHeap(int[] arr, int size, int idx) {
        int tmp = arr[idx];
        for (int i = (idx << 1) + 1; i < size; i++) {
        	//选取子节点的最大值
            if (i + 1 < size && arr[i] < arr[i + 1])
                i++;
            //要下沉的节点比子节点小，交换当前节点和子节点
            if (arr[i] > tmp) {
                arr[idx] = arr[i];
                idx = i;
            } else break;
        }
        arr[idx] = tmp;
    }

    /**
     * 小顶堆
     */
    private void smallHeap(int[] arr, int size, int idx) {
        int tmp = arr[idx];
        for (int i = (idx << 1) + 1; i < size; i++) {
        	//选取子节点的最小值
            if (i + 1 < size && arr[i] > arr[i + 1]) i++;
            //要下沉的节点比子节点大，交换当前节点和子节点
            if (arr[i] < tmp) {
                arr[idx] = arr[i];
                idx = i;
            } else break;
        }
        arr[idx] = tmp;
    }
	//小顶堆排序，降序排列
    public void smallHeapSort(int[] arr) {
        for (int i = arr.length / 2 - 1; i >= 0; i--)
            smallHeap(arr, arr.length, i);
        for (int i = arr.length - 1; i >= 0; i--) {
            int tmp = arr[0];
            arr[0] = arr[i];
            arr[i] = tmp;
            smallHeap(arr, i, 0);
        }
    }
}

• 结果如下
  [2, 2, 3, 4, 4, 5, 6, 7, 8]
  [8, 7, 6, 5, 4, 4, 3, 2, 2]

PS：本人水平有限，文中如有错漏，欢迎大家指出。转载请注明来源。欢迎大家积极回复，学习的路上不想单机（︶︿︶）