下面是 Java 中堆排序、归并排序和桶排序的实现，以及一个简单的程序来比较它们的效率。我们将使用 System.nanoTime() 来测量每种排序算法的运行时间。

堆排序

堆排序是一种基于比较的排序算法，利用二叉堆的数据结构来实现。

javaCopy Codeimport java.util.Arrays;import java.util.Random;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);
        }
    }    private static void heapify(int[] arr, int n, int i) {        int largest = i;        int left = 2 * i + 1;        int right = 2 * i + 2;        if (left < n && arr[left] > arr[largest]) {
            largest = left;
        }        if (right < n && arr[right] > arr[largest]) {
            largest = right;
        }        if (largest != i) {            int swap = arr[i];
            arr[i] = arr[largest];
            arr[largest] = swap;
            heapify(arr, n, largest);
        }
    }
}

归并排序

归并排序是一种分治算法，它将数组分成两半，递归地排序每一半，然后合并已排序的两半。

javaCopy Codepublic class MergeSort {    public static void mergeSort(int[] arr) {        if (arr.length < 2) {            return;
        }        int mid = arr.length / 2;        int[] left = Arrays.copyOfRange(arr, 0, mid);        int[] right = Arrays.copyOfRange(arr, mid, arr.length);
        mergeSort(left);
        mergeSort(right);
        merge(arr, left, right);
    }    private static void merge(int[] arr, int[] left, int[] right) {        int i = 0, j = 0, k = 0;        while (i < left.length && j < right.length) {            if (left[i] <= right[j]) {
                arr[k++] = left[i++];
            } else {
                arr[k++] = right[j++];
            }
        }        while (i < left.length) {
            arr[k++] = left[i++];
        }        while (j < right.length) {
            arr[k++] = right[j++];
        }
    }
}

桶排序

桶排序是一种分配排序算法，它将元素分到不同的桶中，然后对每个桶分别排序，最后合并所有桶中的元素。

javaCopy Codeimport java.util.ArrayList;import java.util.Collections;import java.util.List;public class BucketSort {    public static void bucketSort(int[] arr) {        if (arr.length == 0) {            return;
        }        int max = arr[0];        int min = arr[0];        for (int value : arr) {            if (value > max) max = value;            if (value < min) min = value;
        }        int bucketCount = arr.length;
        List[] buckets = new List[bucketCount];        for (int i = 0; i < buckets.length; i++) {
            buckets[i] = new ArrayList<>();
        }        for (int value : arr) {            int bucketIndex = (value - min) * bucketCount / (max - min + 1);
            buckets[bucketIndex].add(value);
        }        int index = 0;        for (List bucket : buckets) {
            Collections.sort(bucket);            for (int value : bucket) {
                arr[index++] = value;
            }
        }
    }
}

效率比较

我们将使用 System.nanoTime() 来比较这三种排序算法的效率。

javaCopy Codepublic class SortingComparison {    public static void main(String[] args) {        int[] sizes = {1000, 5000, 10000};        Random random = new Random();        for (int size : sizes) {            int[] arr1 = new int[size];            int[] arr2 = new int[size];            int[] arr3 = new int[size];            for (int i = 0; i < size; i++) {                int value = random.nextInt(10000);
                arr1[i] = value;
                arr2[i] = value;
                arr3[i] = value;
            }
            System.out.println("Array size: " + size);            long startTime = System.nanoTime();
            HeapSort.heapSort(arr1);            long endTime = System.nanoTime();
            System.out.println("Heap Sort: " + (endTime - startTime) / 1_000_000 + " ms");
            startTime = System.nanoTime();
            MergeSort.mergeSort(arr2);
            endTime = System.nanoTime();
            System.out.println("Merge Sort: " + (endTime - startTime) / 1_000_000 + " ms");
            startTime = System.nanoTime();
            BucketSort.bucketSort(arr3);
            endTime = System.nanoTime();
            System.out.println("Bucket Sort: " + (endTime - startTime) / 1_000_000 + " ms");
            System.out.println();
        }
    }
}

说明

‌ 堆排序‌：时间复杂度为 $O (n lo g n)$ ，不稳定排序。
‌ 归并排序‌：时间复杂度为 $O (n lo g n)$ ，稳定排序。
‌ 桶排序‌：平均时间复杂度为 $O (n + k)$ ，其中 $k$ 是桶的数量，通常适用于均匀分布的数据，稳定排序。

注意事项

桶排序在数据分布不均匀或范围过大时可能效率不佳。
堆排序和归并排序对大多数数据分布都能保持较好的性能。
实际效率可能因数据特性和实现细节而异。

通过运行 SortingComparison 类的 main 方法，你可以观察到不同排序算法在不同数据规模下的性能表现。

http://blog.liyintong.com

http://blog.naqimai.cn

http://blog.kucedu.cn

http://blog.yueluyan.cn

http://blog.huayuke.cn

http://blog.haizichu.cn

http://blog.yawanmei.cn

http://blog.biaolele.cn

http://blog.shenhebu.cn

http://blog.zimeiren.cn

http://blog.qishouka.cn

http://blog.ruanding.cn

http://blog.xjhsdsc.cn

http://blog.itoren.cn

http://blog.iseebest.cn

http://blog.bndaye.cn

http://blog.rustler.cn

http://blog.excelta.cn

http://blog.diaolift.cn

http://blog.jxpfbyjs.cn

http://blog.banans.cn

http://blog.aspira.cn

http://blog.bxhqw.cn

http://blog.pudiweng.cn

http://blog.tingbu.cn

http://blog.ouhei.cn

http://blog.huiha.cn

http://blog.miuling.cn

http://blog.podang.cn

http://blog.fenkun.cn

http://blog.liangran.cn

http://blog.zouliu.cn

http://blog.xuhou.cn

http://blog.kuopao.cn

http://blog.lunkai.cn

http://blog.zhaiti.cn

http://blog.fogei.cn

http://blog.gengluo.cn

http://blog.wadiao.cn

http://blog.hunjun.cn

http://blog.huanken.cn

http://blog.chuancong.cn

http://blog.buzun.cn

http://blog.zhuozou.cn

http://blog.lazai.cn

http://blog.zengle.cn

http://blog.suidun.cn

http://blog.zhaojunji.cn

http://blog.huihuoban.cn

http://blog.wanjiahua.cn

http://blog.conglinyi.cn

http://blog.henyoupin.cn

http://blog.wuwenkang.cn

http://blog.tujiachen.cn

http://blog.zilaoweng.cn

http://blog.baolema.cn

http://blog.shumeilin.cn

http://blog.anhetong.cn

http://blog.wenjishu.cn

http://blog.kansande.cn

http://blog.yueshijie.cn

http://blog.tihujiu.cn

http://blog.huatoutou.cn

http://blog.xiaolaige.cn

http://blog.huguangu.cn

http://blog.lvdate.cn

http://blog.kesini.cn

http://blog.soubianlu.cn

http://blog.fuenbu.cn

http://blog.liuyakun.cn

http://blog.zouyizou.cn

http://blog.juyingba.cn

http://blog.namahu.cn

http://blog.dadudu.cn

http://blog.xuewenzi.cn

http://blog.lazhuyong.cn

http://blog.aizishu.cn

http://blog.nianjiepo.cn

http://blog.baisuijie.cn

http://blog.wanyuecun.cn

http://blog.shoupashu.cn

http://blog.hetongmei.cn

http://blog.ouenming.cn

http://blog.qianyiduo.cn

http://blog.yidingzhi.cn

http://blog.zouyuming.cn

http://blog.mofaya.cn

http://blog.hexiangru.cn

http://blog.quyouban.cn

http://blog.mingyinsi.cn

http://blog.junepan.cn

http://blog.qiyuehong.cn

http://blog.ledatong.cn

http://blog.chenqinga.cn

http://blog.ebuyun.cn

http://blog.gayijiu.cn

http://blog.liqinge.cn

http://blog.liubawan.cn

http://blog.huabaohan.cn

http://blog.aiguandan.cn

http://blog.judoubang.cn

http://blog.huachenyu.cn

http://blog.hexiaolia.cn

http://blog.feiyuxuan.cn

http://blog.zhenwasai.cn

http://blog.maoweilai.cn

http://blog.yunyuewei.cn

http://blog.kemensen.cn

http://blog.anxinyuan.cn

http://blog.deyisheji.cn

http://blog.ximaguohe.cn

http://blog.gewukeji.cn

http://blog.rehuang.cn

java编写堆排序、归并排序、桶排序并比较效率。

堆排序

归并排序

桶排序

效率比较

说明

注意事项