堆排序专题-把一个数组变成大根堆的两种方式和根据大根堆来实现对数组的排序,

什么是堆排序

堆排序（Heap Sort）是一种基于二叉堆数据结构的排序算法。它的基本思想是将待排序的数组构建成一个大根堆或小根堆，然后依次将堆顶元素与堆尾元素交换，并重新调整堆，直到整个数组有序。
堆排序的时间复杂度为O(nlogn)，是一种稳定的排序算法。堆排序的基本步骤如下：

如何构建堆

构建堆：首先将待排序数组构建成一个大根堆或小根堆。具体地，可以将数组中的每个元素与堆顶元素进行比较，如果该元素比堆顶元素小，则将其与堆顶元素交换，并将该元素与堆的根节点交换，这样就将原来的小根堆变成了大根堆。重复这个过程，直到堆顶元素不再变化，此时整个数组就已经有序。
排序：将堆顶元素与堆尾元素交换，并重新调整堆，直到整个数组有序。
堆排序的实现方式有很多种，其中最常用的是堆排序算法（Heap Sort Algorithm，HSA）。HSA是一种基于快速排序算法的改进算法，它通过维护一个大根堆来实现堆排序。具体实现步骤如下：
选择一个基准元素（pivot），将其与堆顶元素交换。
重复步骤1，直到堆顶元素不再变化。
将堆顶元素与堆的根节点交换，并重新调整堆，直到整个数组有序。
HSA的时间复杂度为O(nlogn)，是一种稳定的排序算法。

下面直接代码演示如何构建大根堆

/**
     * 通过 对每一个位置上的数字进行逻辑上大根堆的结构改造 实现大根堆
     * @param arr
     * @param index
     */
    public static void heapInsert(int[]arr,int index){
        //当前节点的父节点 就是 (index - 1 ) / 2
        //这个比较是当前节点如果比父节点大,那和父节点要进行交换
        //如果当前节点就是父节点那么循环不会执行,因此下面两行代码就可以实现一次元素的逻辑交换,来满足大根堆
        while (arr[index] > arr[(index - 1) / 2]){
            swap(arr,index,(index - 1) / 2);
            //进行下一次比较
            index = (index - 1) / 2;
        }
    }

第二种方式来构建大根堆

 /**
     * 构造大根堆
     * @param arr
     * @param index
     * @param heapSize
     */
    public static void heapfiy(int[]arr,int index,int heapSize){
        //当前节点的左孩子
        int left = index * 2 + 1;
        //循环可以执行的条件是 左孩子 没超过总元素的长度 ,也就是要有左孩子
        while (left < heapSize){
            //先进行标记 如果有右孩子,就和左孩子比较,谁比较大 把最大下标赋值上,如果没有右孩子,就先把左孩子下标给最大值下标
            int maxIndex = left + 1 < heapSize && arr[left] < arr[left + 1] ? left + 1 : left;
            //上一步完成左右孩子谁是最大值,现在要把比较出来的结果和父节点比较了,谁大把下标赋值上
            maxIndex = arr[index] < arr[maxIndex] ? maxIndex : index;
            //如果当前节点就是最大值,那么就不需要继续执行了,已经符合大根堆的要求了
            if (index == maxIndex){
                break;
            }
            //最大值是左右孩子其中一个的话,和当前元素进行交换
            swap(arr,index,maxIndex);
            //index 变成下面的交换下来的位置
            index = maxIndex;
            //刚交换下来 要继续和自己的孩子进行比较,拿到左孩子的下标,开启下一个循环
            left = index * 2 + 1;
        }
    }

注意上面两种方式虽然都是可以构建大根堆,但都要掌握,两者可以同时用,如果一个大根堆上某一个元素被人改掉了,两个方法同时用,就可以使其恢复大根堆
下面代码演示:

 /**
     * 当某一个位置被改了 可以用下面方式来时期恢复
     * @param arr
     * @param i
     */
    public static void modify(int[]arr,int i){
        //两个方法 只会满足一个去执行
        heapInsert(arr,i);
        heapfiy(arr,i,arr.length);
    }

使用大根堆 对数组进行排序,直接上代码

  /**
     * 使用大根堆排序的思想就是,不断把最顶上的元素,和最后一个元素进行交换
     * 然后把最后一个断开,再把刚换上来的元素去重新构建大根堆,一直循环这个操作,
     * 就可以完成排序了
     * @param arr
     */
    public static void heapSort(int[]arr){
        if (null == arr || arr.length < 2){
            return ;
        }
        //先把一个数组变成逻辑上的大根堆数组
        for (int i = 0;i < arr.length;i++){
            heapInsert(arr,i);
        }

        //第二种方式 实现大根堆 这个效率更高
//        for (int i = arr.length - 1; i >= 0;i--){
//            heapfiy(arr,i,arr.length);
//        }
        int heapSize = arr.length ;
        //先把根节点和最后一个进行交换,然后逻辑上断开和最后一个的联系
        swap(arr,0,--heapSize);
        //heapSize 没到0 就一直循环操作把根元素调到当前最后一个节点.
        while (heapSize > 0){ //O(N) 时间复杂度
            //先把交换来的元素,重新变成大根堆,不断和下面元素比较
            heapfiy(arr,0,heapSize); //O(logN)
            swap(arr,0,--heapSize);//O(1)
        }
    }