[JAVA]堆排序

package sort_book_datastruction;

import java.util.Arrays;
/**
 * 这是一个建立最大顶堆的过程,根节点值最大, 与最后一个元素进行交换之后,
 * 然后对剩下的元素进行筛选,即调整堆。
 * 两步:1.建堆;2。帅选
 * @author Administrator
 *
 */
public class HeapSort {
    /**
     * 自堆顶至叶子的调整过程,即帅选;
     * @param array
     * @param s  待调整根节点的位置。
     * @param length
     */
    public void heapAdjust(int[] array,int s, int length){
        int temp = array[s];
        int child = 2*s+1;//左孩子节点位置;//左孩子结点的位置。(i+1 为当前调整结点的右孩子结点的位置)  

        while(child<length){
             // 如果右孩子大于左孩子(找到比当前待调整结点大的孩子结点)  
             if(child+1<length&&array[child]<array[child+1])
                 child++;//找到孩子节点比待调整节点大的位置上
             if(array[s]<array[child]){ // 如果较大的子结点大于父结点  
                 array[s] = array[child];// 那么把较大的子结点往上移动,替换它的父结点  
                 s=child; // 重新设置s ,即待调整的下一个结点的位置  
                 child = 2*s+1;
             }else{// 如果当前待调整结点大于它的左右孩子,则不需要调整,直接退出  
                 break;
             }
             array[s] =temp;//把待调整的节点放到比其大的孩子节点上
        }
    }

    /**
     * 初始化建堆
     * 将array[a...length-1]建成堆
     * 这是一个反复帅选的过程。
     * @param array
     * @param length
     */
    public void buildingHeap(int[] array,int length){
         //最后一个有孩子的节点的位置 i=  (length -1) / 2  
        for(int i =(length-1)/2;i>=0;i--){
            heapAdjust(array,i,length);
        }
    }
    public void heapSort(int[] array,int length){
        //初始堆
        buildingHeap(array,length);
        //从最后一个元素开始对序列进行调整  
        for(int i = length -1;i>0;--i){
            //交换堆顶元素H[0]和堆中最后一个元素  
            int temp = array[i];
            array[i] = array[0];
            array[0] =temp;
            //每次交换堆顶元素和堆中最后一个元素之后,都要对堆进行调整  
            heapAdjust(array,0,i);
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        HeapSort hs =new HeapSort();
        int[] array = {49,38,65,97,76,13,27,49};
        hs.heapSort(array, array.length);
        System.out.println(" "+Arrays.toString(array));

    }

}
### Java堆排序的实现与原理 #### 1. 堆排序的基本原理 堆排序是一种基于比较的排序算法,主要依赖于一种称为“堆”的特殊数据结构。堆可以分为两种形式:**大顶堆**和**小顶堆**。 - **大顶堆**是指父节点的值总是大于等于子节点的值。 - **小顶堆**则是指父节点的值总是小于等于子节点的值。 堆排序的核心思想是先将待排序的数据构建为一个大顶堆(或小顶堆)。对于升序排序来说,通常采用大顶堆;而对于降序排序,则使用小顶堆。随后不断取出堆顶元素(即当前最大值或最小值),并将剩余部分重新调整成一个新的堆,直到所有元素都被处理完毕[^3]。 #### 2. 构建堆的过程 为了完成堆排序,需要解决两个核心问题: 1. 将无序数组转换为一个合法的大顶堆。 2. 在每次移除堆顶元素后,能够动态维护剩下的部分仍满足堆的定义。 ##### (a) 调整堆的操作 假设已经有一个接近堆结构的部分数组,可以通过自底向上的方式逐步修复堆属性。具体做法是从某个非叶子节点开始向下遍历,如果发现该节点不符合堆的要求(比如在大顶堆中,父节点小于子节点),则交换父子节点的位置,并继续递归地检查被交换后的子节点是否仍然违反堆规则[^4]。 以下是调整堆的一个伪代码表示: ```java private void heapify(int[] array, int length, int i) { int largest = i; // 初始化最大值索引为根节点 int leftChild = 2 * i + 1; int rightChild = 2 * i + 2; // 如果左孩子存在且大于当前最大值 if (leftChild < length && array[leftChild] > array[largest]) { largest = leftChild; } // 如果右孩子存在且大于当前最大值 if (rightChild < length && array[rightChild] > array[largest]) { largest = rightChild; } // 如果最大值不是根节点,交换它们并递归调用heapify if (largest != i) { swap(array, i, largest); heapify(array, length, largest); // 继续下沉 } } ``` ##### (b) 初始堆化过程 初始阶段,我们需要把整个输入数组转化为一个完整的堆。由于完全二叉树的特点决定了最后一个非叶节点位于 `(n/2)-1` 的位置,所以可以从这个位置向前依次对每一个内部节点执行 `heapify` 操作[^1]。 #### 3. 完整的堆排序流程 一旦完成了初始化堆的工作之后,就可以按照如下步骤来进行最终的排序: 1. 取出堆顶元素放到已排序区域的最后一项; 2. 缩短未排序区间的长度; 3. 对新的未排序区间再次进行 `heapify` 处理以恢复堆特性; 4. 循环上述三步直至全部元素都进入到了已排序状态之中。 下面是完整的 Java 实现代码: ```java public class HeapSort { public static void sort(int[] array) { int n = array.length; // Build max heap. for (int i = n / 2 - 1; i >= 0; i--) { heapify(array, n, i); } // Extract elements one by one from the heap and place them at their correct positions. for (int i = n - 1; i > 0; i--) { // Move current root to end of unsorted part. swap(array, 0, i); // Call max heapify on reduced heap. heapify(array, i, 0); } } private static void heapify(int[] array, int length, int i) { int largest = i; // Initialize largest as root int leftChild = 2 * i + 1; int rightChild = 2 * i + 2; // If left child is larger than root if (leftChild < length && array[leftChild] > array[largest]) { largest = leftChild; } // If right child is larger than largest so far if (rightChild < length && array[rightChild] > array[largest]) { largest = rightChild; } // If largest is not root if (largest != i) { swap(array, i, largest); heapify(array, length, largest); // Recursively heapify affected sub-tree } } private static void swap(int[] array, int i, int j) { int temp = array[i]; array[i] = array[j]; array[j] = temp; } public static void main(String[] args) { int[] data = {4, 10, 3, 5, 1}; System.out.println("Original Array:"); printArray(data); sort(data); System.out.println("\nSorted Array:"); printArray(data); } private static void printArray(int[] array) { for (int value : array) { System.out.print(value + " "); } } } ``` 这段程序展示了如何通过堆排序技术有效地对一组随机数列实施升序排列[^2]。 --- ### 总结 堆排序以其时间复杂度 $O(n \log n)$ 和原地工作的特点,在很多场合下表现出色。虽然它不像快速排序那样平均表现更佳,但它具有最坏情况下的线性对数级效率优势[^5]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值