Algorithm 如何从两种排序算法中确定最快的排序算法？

我有两种算法

一,

void sort3（整数*质量，整数大小）
{
int i=0；
int j=尺寸-1；
内部温度；
int mid=质量[尺寸/2]；
做
{
while（质量[i]mid）
{
j--；
}
如果（i=last）| |（质量[左开始]<质量[右开始]）
{
工作质量[j]=质量[开始质量左]；
开始左++；
}
其他的
{
工作质量[j]=质量[start_right]；
右开始++；
}
}
对于（int j=0；j1）
{
sort4（质量，尺寸/2）；
sort4（和质量[size/2]，size-size/2）；
sort4_准备（质量、尺寸）；
}
}

---

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

sort3

是一个实现，在最坏的情况下，它的时间复杂度为O（n²），但平均为O（nlogn）

sort4

是一种在最坏和平均情况下都具有O（nlogn）性能的实现

但是，这并不意味着即使在快速排序的最坏情况下，

sort4

对于1000个数字的数组也能保证更快。这只意味着对于某些类别的数组（快速排序的“最坏情况”类型的数组），存在一个数组大小，超过该大小，

sort4

将更快。对于排序任何数组所需的平均时间，我们无从谈起，因为它们的平均时间复杂度相同

此外，您将不知道它的大小高于哪个Mergesort在Quicksort的“最坏情况”数组上会表现得更好，因为这取决于实现问题：例如，一个编译器可能会编译您的代码，而

sort4

中的

delete

操作在时间上非常昂贵，因此，对于大多数大小合理的阵列，

sort3

可能总是更快。这并不牵强，因为实际上，

sort4

与

sort3

的不同之处在于它需要创建一个额外的数组将值复制到其中，然后再次删除该数组。这是

sort3

没有的开销

---

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

为什么不用一个随机数组每次重复10000次，并测量总时间？但是，关于这一点的任何数学证明都没有帮助，因为每个操作的原子持续时间都未知，并且取决于实现（编译器和处理器）方面。您可以考虑确定时间复杂度，但这并不能保证一个算法在给定输入下会比另一个算法运行得更快，只能保证当输入足够大（可能非常大）时，一个算法会运行得更快。

 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);
    }
}

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);
    }
}