Question

我有两种算法。

1

 void sort3(int *mass, int size)
{
    int i = 0;
    int j = size - 1;
    int temp;
    int mid = mass[size / 2];
    do
    {
        while (mass[i] < mid)
        {
            i++;
        }
        while (mass[j] > mid)
        {
            j--;
        }
        if (i <= j)
        {
            temp = mass[i];
            mass[i] = mass[j];
            mass[j] = temp;
            i++;
            j--;
        }
    } while (i <= j);

    if (j > 0)
    {
        sort3(mass, j + 1);
    }
    if (i < size)
    {
        sort3(&mass[i], size - i);
    }
}

2。

void sort4_prepare(int *mass, int size)
{
    int middle, start_left, start_right, last;
    int *work_mas = new int[size];
    middle = size / 2;
    start_left = 0;
    start_right = middle;
    last = size;
    for (int j = 0; j < last; j++)
    {
        if ((start_left < middle) && ((start_right >= last) || (mass[start_left] < mass[start_right])))
        {
            work_mas[j] = mass[start_left];
            start_left++;
        }
        else
        {
            work_mas[j] = mass[start_right];
            start_right++;
        }
    }
    for (int j = 0; j < last; j++)
        mass[j] = work_mas[j];
    delete[] work_mas;
};

void sort4(int *mass, int size)
{
    if (size > 1)
    {
        sort4(mass, size / 2);
        sort4(&mass[size / 2], size - size / 2);
        sort4_prepare(mass, size);
    }
}

我还有一个从最大到最小排序的1000个随机数的数组。哪种算法会将数组从最小值排序到最大值？我做了一些测试，我认为这是第一个，但我不知道如何证明它。但是，在某些情况下，第二个会比第一个更快，这使我在测试中有点不确定。

Answer 1

sort3是QuickSort的一种实现，在最坏的情况下具有 O（n²）时间复杂度，但 O（nlogn）平均而言。

sort4是MergeSort的一种实现，在最差和普通情况下都具有 O（nlogn）的性能。

但是，这并不意味着{1000}数组的sort4保证更快，即使在Quicksort最糟糕的情况下也是如此。它只意味着对于某些类别的数组（Quicksort的“最坏情况”类型的数组），存在一个数组大小， sort4将更快。关于平均排序任何阵列所需的时间，没有什么可说的，因为它们平均具有相同的时间复杂度。

此外，你不知道Mergesort在Quicksort的“最坏情况”数组上会表现得更好的大小，因为这取决于实现问题：例如，一个编译器可能以一种方式编译你的代码delete sort4中的sort3操作在时间上非常，因此对于大多数合理大小的数组，sort4可能总是更快。这并非牵强附会，因为sort3与sort3的不同之处在于它需要创建一个额外的数组来复制值，然后再次删除该数组。这是url没有的开销。

确定平均一个函数对于给定数组大小是否比另一个函数排序更快的唯一实用方法是获得统计度量：重复排序操作多次在一些随机填充的数组上具有代表性，并且衡量时差。但是，当在不同的配置上运行时，这种测试的结果可能会有所不同。

如何确定两个中最快的排序算法？

1 个答案: