堆排序—Java

package sort;


public class heapSort {
    //  前 n个是大顶堆
    static void percUp(int[] a, int n, int k){
        
        int hole = n + 1; //在数组中排第几个输, index
        while(hole/2 >= 1 && k > a[hole/2 - 1]){
                a[hole - 1] = a[hole/2 - 1];
                hole = hole/2;
        }
        a[hole - 1] = k;        
    }   //n = 0, index = 1, perfect......


    static void buildMaxHeap(int[] a){
        for(int n = 0; n<= a.length - 1; n++){
            int k = a[n];
            percUp(a, n, k);
        }
    }


    static void deleteMax(int[] a, int length){
        if( 0 == length)
            return;
        
        int lastElement = a[length -1];
        
        int result = a[0];
        int hole = 1;//  空穴的位置


        while(hole * 2 + 1 <= length){
            if(a[hole *2 -1] > lastElement || a[hole * 2] > lastElement){
                if( a[hole *2 -1] > a[hole * 2]){
                    a[hole - 1] = a[hole *2 -1];
                    hole = hole * 2;
                }
                else{
                    a[hole - 1] = a[hole* 2];
                    hole = hole * 2  + 1;
                }
            }
            else
                break;
        }
        a[hole -1] = lastElement;
        a[length -1] = result;
    }
    
    static void heapSort(int[] a){
        buildMaxHeap(a);
        
        for(int length  = a.length; length >=0; length --){
            deleteMax(a, length);
        }
    }
    
    public static void main(String[] args) {


        
        int[] array_1 = {45, 34, 23, 1, 2, 18, 80};
        int[] array_2 = {34, 23, 1, 2, 18, 80};
        int[] array_3 = {11, 12, 5, 1, 2, 3};
        int[] array_4 = {2, 2, 2, 2, 2};
        int[] array_5 = {2, 3};
        int[] array_6 = {2};
        int[] array_7 = {5, 4, 3, 2, 1};
        
        buildMaxHeap(array_1);
        buildMaxHeap(array_2);
        buildMaxHeap(array_3);
        buildMaxHeap(array_4);
        buildMaxHeap(array_5);
        buildMaxHeap(array_6);
        buildMaxHeap(array_7);
        


        heapSort(array_1);
        heapSort(array_2);
        heapSort(array_3);
        heapSort(array_4);
        heapSort(array_5);
        heapSort(array_6);
        heapSort(array_7);
        
        System.out.println("hello world");
    }


}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
堆排序是一种基于二叉堆数据结构的排序算法,它的时间复杂度为O(nlogn)。下面是一个使用Java实现的堆排序代码示例: ```java public class HeapSort { public static void heapSort(int[] arr) { int n = arr.length; // 构建最大堆 for (int i = n / 2 - 1; i >= 0; i--) heapify(arr, n, i); // 逐个将堆顶元素移到数组末尾 for (int i = n - 1; i > 0; i--) { // 将当前堆顶元素(最大值)与数组末尾元素交换 int temp = arr[0]; arr[0] = arr[i]; arr[i] = temp; // 重新构建最大堆 heapify(arr, i, 0); } } // 调整以index为根节点的子树为最大堆 public static void heapify(int[] arr, int n, int index) { int largest = index; // 初始化最大值为根节点 int left = 2 * index + 1; // 左子节点索引 int right = 2 * index + 2; // 右子节点索引 // 如果左子节点大于根节点,则更新最大值索引 if (left < n && arr[left] > arr[largest]) largest = left; // 如果右子节点大于当前最大值,则更新最大值索引 if (right < n && arr[right] > arr[largest]) largest = right; // 如果最大值不是根节点,则交换根节点和最大值 if (largest != index) { int swap = arr[index]; arr[index] = arr[largest]; arr[largest] = swap; // 递归调整交换后的子树 heapify(arr, n, largest); } } public static void main(String[] args) { int[] arr = { 12, 11, 13, 5, 6, 7 }; heapSort(arr); System.out.println("排序后的数组:"); for (int i : arr) { System.out.print(i + " "); } } } ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值