Question

我正在尝试编写一个比较四种不同排序算法（mergesort，quicksort，heapsort，insertionsort）的运行时间的方法。我试图用for循环的每次迭代计算每个算法，这增加了每个循环随机生成的数组的数组大小。我工作的代码但是花费了太多时间。在循环结束时，我正在计算每个排序算法从1到100大小接管数组的平均时间。

注意：generateArray（num）只是创建一个填充了大小为num的随机整数的数组。

我不是一个如此优秀的程序员，更好地实现它的方法是什么？

以下是代码段：

static void testArrays() {
    ThreadMXBean bean = ManagementFactory.getThreadMXBean();
    long insertionCount=0, mergeCount=0, 
            quickCount=0, heapCount = 0;

    for (int i=1; i<100; i++) {
        long[] A = generateArray(i);
        long[] copy1 = A.clone();
        long[] copy2 = A.clone();
        long[] copy3 = A.clone();

        long startTime1 = bean.getCurrentThreadCpuTime();
        insertionSort(A);
        long endTime1 = bean.getCurrentThreadCpuTime();
        long duration = endTime1 - startTime1;
        insertionCount = insertionCount + duration;

        long startTime2 = bean.getCurrentThreadCpuTime();
        mergeSort(copy1);
        long endTime2 = bean.getCurrentThreadCpuTime();
        long mergeDuration = endTime2 - startTime2;
        mergeCount = mergeCount + mergeDuration;

        long startTime3 = bean.getCurrentThreadCpuTime();
        heapSort(copy2);
        long endTime3 = bean.getCurrentThreadCpuTime();
        long heapDuration = endTime3 - startTime3;
        heapCount = heapCount + heapDuration;


        long startTime4 = bean.getCurrentThreadCpuTime();
        quickSort(copy3);
        long endTime4 = bean.getCurrentThreadCpuTime();
        long quickDuration = endTime4 - startTime4;
        quickCount = quickCount + quickDuration;

    } 
    long averageIS = insertionCount/10000;
    long averageMS = mergeCount/10000;
    long averageHS = heapCount/10000;
    long averageQS = quickCount/10000;
    System.out.println("Insertion Sort Avg: " + averageIS);
    System.out.println("MergeSort Avg: " + averageMS);
    System.out.println("HeapSort Avg: " + averageHS);
    System.out.println("QuickSort Avg: " + averageQS);
}

Answer 1

有比较排序和分发排序。

比较排序方法是一种通过比较两个要一次比较的键值并进行交换来执行排序的方法

分布式排序是一种根据键值将数据划分为多个子集的方法，并对每个子集进行排序以对整体进行排序。

众所周知，快速排序是最快的。在最坏的情况下，当枢轴处于最小值和最大值时，会发生n²。为避免这种情况，请随机使用pivot或三分之三分区。平均而言，它会产生最佳性能。

插入排序是已排序数据的最快速度。如果它们已经排序，则仅将它们与第一个元素进行比较。

上述算法的时间复杂度如下：

O（n²）：冒泡排序，选择排序，插入排序，外壳排序，快速排序

O（n log n）：堆排序，合并排序

O（kn）：基数排序（k有一个约束，它可以在低位和低位的4字节整数下表现良好）。

对基于输入大小的不同排序算法的持续时间感到困惑？

1 个答案: