堆排序（升序，降序，迭代，递归写法）

堆排序

1. 是一种选择排序。 平均时间复杂度为0(nlogn),是不稳定排序
2. 大顶堆: 完全二叉树，每个节点的值都大于或等于其左右子节点的值。（左右子节点的值不作要求）
3. 小顶堆：完全二叉树，每个节点的值都小于或等于其左右子节点的值

大顶堆:

小顶堆:

堆排序的基本思想

1. 将待排序序列构造层一个大顶堆 （左节点2n+1； 右节点2n+2； 父节点(i-1)/2）
2. 序列的最大值处于，顶部的根节点
3. 先将数组变成大顶堆形式
4. 将大顶堆堆顶与最小叶子节点交换，使大顶堆位于最小叶子节点除，将其移除（后面不考虑）
5. 在对其剩余顶堆进行处理，使其重新变成大顶堆
6. 循环4-5，直至所有元素被移除

升序

class HeapSort {
    public static void heapSort(int[] arr){
        // 首先将arr变成大顶堆
        bigHeap(arr);
        int size = arr.length;
        while (size > 1){
            //将堆顶与最小叶子节点进行交换
            swap(arr,0,size-1);
            // 将此时最小叶子节点移除（前堆顶）
            size--;
            // 将剩余数组重新变成大堆顶
            heapRestRec(arr,0,size);
        }
    }

    // 将一个数组变成大堆顶形式
    public static void bigHeap(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            int currentIndex = i;
            int fatherIndex = (i-1)/2;
            while (arr[fatherIndex]<arr[currentIndex]){
                swap(arr,fatherIndex,currentIndex);
                // 将现节点往上移，看上面是否满足情况
                currentIndex = fatherIndex;
                fatherIndex = (currentIndex-1)/2;
            }
        }
    }

    // 将其重新变成大堆顶形式
    // 迭代写法
    public static void heapRest(int[] arr, int index, int size){
        int left = index*2 +1;
        int right = index*2 +2;
        int bigIndex;
        // 直到所有节点都大于子节点退出
        while (left < size){
            // 比较左右叶子节点大小，记录为bigindex
            if (right <size && arr[right] > arr[left] ){
                bigIndex = right;
            }else {
                bigIndex = left;
            }
            // 如果子节点的最大值大于父节点，则进行交换
            if (arr[bigIndex] > arr[index]){
                swap(arr,bigIndex,index);
                // 为了确保交换后的子节点仍然大于其子子节点，将index换为bigIndex,继续与其子节点进行比较
                index = bigIndex;
                left = index*2 +1;
                right = index*2 +2;
            }else {
                // 如果父节点大于子节点，则跳出循环
                break;
            }
        }
    }

    // 将其重新变成大堆顶形式
    // 递归写法
    public static void heapRestRec(int[] arr, int index, int size){
        int left = index*2 +1;
        int right = index*2 +2;
        int bigIndex;
        // 确定递归的出口，即右节点超出数组引索范围
        if (left >= size){
            return;
        }
        if (right<size && arr[right]> arr[left]){
            bigIndex = right;
        }else {
            bigIndex = left;
        }
        if (arr[bigIndex] > arr[index]){
            swap(arr,bigIndex,index);
            // 将bigindex作为父节点，继续下探
            heapRestRec(arr,bigIndex,size);
        }
    }

    public static void swap(int[] arr, int ind1, int ind2){
        int temp = arr[ind1];
        arr[ind1] = arr[ind2];
        arr[ind2] = temp;
    }

    public static void main(String[] args) {
        int [] arr = {1,2,34,5,6,8};
        heapSort(arr);
        for (int e: arr
             ) {
            System.out.println(e);
        }
    }
}

降序：

public static void heapSortDescent(int[] arr){
        // 现将其转换为小顶堆
        smallHeap(arr);
        int size = arr.length;
        while (size > 1){
            swap(arr,0,size-1);
            size--;
            smallHeapRes(arr,0,size);
        }
    }

    // 将数组转换为小顶堆
    public static void smallHeap(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            int cur = i;
            int father = (i-1)/2;
            while (arr[cur] < arr[father]){
                swap(arr,cur,father);
                cur = father;
            }
        }
    }

    // 将剩余数组转换为小顶堆
    private static void smallHeapRes(int[] arr, int index, int size) {
        int left = index*2+1;
        int right = index*2 +2;
        int smallInd;

        if (left >= size){
            return;
        }

        if (right < size && arr[right]<arr[left]){
            smallInd = right;
        }else {
            smallInd = left;
        }
        if (arr[index] > arr[smallInd]){
            swap(arr,index,smallInd);
            smallHeapRes(arr,smallInd,size);
        }

    }
    public static void main(String[] args) {
        int [] arr = {1,2,34,5,6,8};
        heapSortDescent(arr);
        for (int e: arr
             ) {
            System.out.println(e);
        }
    }
}