堆排序的java实现

有时利用特殊的数据结构可以极大的提高计算机的运算效率，堆排序利用了完全二叉树的便捷性，提高了排序的效率，时间复杂度为O(nlogn)

1. 递归实现:

public class HeapSort {
    public static void main(String[] args) {
        int[] arr = new int[] {30, 42, 7, 66, 3, 51, 67, 21, 19, 45};
        sort(arr);
    }

    public static void sort(int[] arr) {
        buildHeap(arr);     // 构建大顶堆
        for(int a: arr) {
            System.out.print(a + " ");
        }   // 打印 67 66 51 42 45 30 7 21 19 3
        System.out.print("\n");
        int temp;
        for(int i = arr.length - 1; i > 0; i--) {
            // 依次交换堆顶(最大值)到最后一个结点
            temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            rebuildHeap(arr, 0, i); // 交换完成对前i个结点重构
        }
        for(int a: arr) {
            System.out.print(a + " ");
        }   // 打印 3 7 19 21 30 42 45 51 66 67
    }

    /**
     * 传入数组，构建大顶堆
     * @param arr
     */
    public static void buildHeap(int[] arr) {
        for(int i = arr.length / 2 - 1; i >= 0; i--) {
            // 从后向前, 从最后一个非叶子结点开始构建大顶堆
            rebuildHeap(arr, i, arr.length);    // 调用局部堆重构
        }
    }

    /**
     * 传入数组arr, 对给定的起始位置i和结束位置n-1的局部堆进行重构
     * @param arr
     * @param i
     * @param n
     */
    public static void rebuildHeap(int[] arr, int i, int n) {
        int temp = arr[i];
        int j = 2*i+1;
        if(j+1 < n) {   // i结点有2个子结点
            if(arr[j] < arr[j+1]) {
                j++;
            }           // 找到最大的一个子结点
            if(temp < arr[j]) { // 需要重构
                arr[i] = arr[j];
                arr[j] = temp;
                rebuildHeap(arr, j, n); // 重构完成之后需要检查交换的子结点是否需要重构
            }
        } else if(j < n) {  // 只有1个子结点
            if(temp < arr[j]) {
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }   // 没有子结点, 本身就是叶子结点，直接结束
    }
}

2. 循环实现：

public static void sort(int[] arr) {
        buildHeap1(arr);
        for(int a: arr) {
            System.out.print(a + " ");
        }
        System.out.print("\n");
        int temp;
        for(int i = arr.length - 1; i > 0; i--) {
            temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            rebuildLoop(arr, 0, i);
        }
        for(int a: arr) {
            System.out.print(a + " ");
        }
    }
    public static void buildHeap(int[] arr) {
        for(int i = arr.length / 2 - 1; i >= 0; i--) {
            rebuildLoop(arr, i, arr.length);
        }
    }
    public static void rebuildLoop(int[] arr, int i, int n) {
        int j, temp;
        while(2*i+1 < n) {  // 利用左结点判断i是否有子结点
            temp = arr[i];
            j = 2*i+1;
            if(j+1 < n) {   // 有右子结点
                if(arr[j] < arr[j+1]) {
                    j++;
                }
                if(temp < arr[j]) {
                    arr[i] = arr[j];
                    arr[j] = temp;
                } else {
                    break;  // 可以省去剩下多余的循环检查
                }
            } else {
                if(temp < arr[j]) {
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
                break;  // 可以省去一次比较
            }
            i = j;
        }
    }

来源：CSDN

作者：QngCken

链接：https://blog.csdn.net/weixin_44055380/article/details/104552280