大桌子的快速排序出奇地慢

Question

我一直在做作业，比较一堆排序算法，我遇到了一个奇怪的现象。事情正如预期的那样：插入排序赢得了诸如 20 个整数的表之类的东西，否则快速排序优于堆排序和归并排序。最多包含 500,000 个整数的表（存储在内存中）。对于 5,000,000 个整数（仍存储在内存中），快速排序突然变得比堆排序和归并排序更糟。数字始终是均匀分布的随机数，windows 虚拟内存关闭。有人知道这可能是什么原因吗？

     void quicksortit(T *tab,int s) {
                   if (s==0 || s==1) return;
                   T tmp;
                   if (s==2) {
                      if (tab[0]>tab[1]) {
                                         tmp=tab[0];
                                         tab[0]=tab[1];
                                         tab[1]=tmp;
                                         }
                      return;
                      }
                   T pivot=tab[s-1];
                   T *f1,*f2;
                   f1=f2=tab;
                   for(int i=0;i<s;i++)
                           if (*f2>pivot)
                              f2++;
                           else {
                                tmp=*f1;
                                *f1=*f2;
                                *f2=tmp;
                                f1++; f2++;
                                }
                   quicksortit(tab,(f1-1)-tab);
                   quicksortit(f1,f2-f1);
     };

Answer 1

可能是您的数组现在比 L3 缓存大。

快速排序分区操作将随机元素从数组的一端移动到另一端。典型的 Intel L3 缓存为 8MB。使用 5M 4 字节元素 - 您的数组为 20MB。你正在从它的一端写到另一端。

L3 之外的缓存未命中进入主内存，并且可能比更高级别的缓存未命中慢很多。

到目前为止，您的整个排序操作完全在 CPU 内部运行。

Answer 2

当数组中有许多重复项时，您的算法开始失败。您只在大值时注意到了这一点，因为您一直在为算法提供具有大跨度的随机值
（我假设您使用 rand() 和：0 - RAND_MAX ），并且该问题仅出现在大数组中。

当您尝试对相同数字的数组进行排序时（尝试对 100000 个相同的数字进行排序，程序将崩溃），您将首先遍历整个数组，不必要地交换元素。然后你把数组一分为二，但是大数组只减了1：

                    v
quicksortit(tab,(f1-1)-tab);

因此，您的算法变为 O(n^2)，并且您还消耗了大量的堆栈。在这种情况下，寻找更好的支点对您没有帮助，而是选择不存在此缺陷的 quicksort() 版本。

例如：

function quicksort(array)
    if length(array) > 1
        pivot := select middle, or a median of first, last and middle
        left := first index of array
        right := last index of array
        while left <= right
            while array[left] < pivot
                left := left + 1
            while array[right] > pivot
                right := right - 1
            if left <= right
                swap array[left] with array[right]
                left := left + 1
                right := right - 1
        quicksort(array from first index to right)
        quicksort(array from left to last index)

修改版：http://rosettacode.org/wiki/Sorting_algorithms/Quicksort