基准

Question

我正在解决一个问题，它涉及非常快速地排序10个数字（int32）。我的应用程序需要尽可能快地对10个数字进行数百万次排序。我对数十亿个元素的数据集进行采样，每次我需要从中挑选10个数字（简化）并对它们进行排序（并从排序的10个元素列表中得出结论）。

目前我正在使用插入排序，但我想我可以为我的10个数字的特定问题实现一个非常快速的自定义排序算法，这将超过插入排序。

有没有人知道如何处理这个问题？

Answer 1

（继续关注HelloWorld的建议，研究排序网络。）

似乎29比较/交换网络是进行10输入排序的最快方法。我使用了Waksman在1969年发现的网络在Javascript中的这个例子，它应该直接翻译成C，因为它只是if语句，比较和交换的列表。

＆＃13;

function sortNet10(data) {	// ten-input sorting network by Waksman, 1969
    var swap;
    if (data[0] > data[5]) { swap = data[0]; data[0] = data[5]; data[5] = swap; }
    if (data[1] > data[6]) { swap = data[1]; data[1] = data[6]; data[6] = swap; }
    if (data[2] > data[7]) { swap = data[2]; data[2] = data[7]; data[7] = swap; }
    if (data[3] > data[8]) { swap = data[3]; data[3] = data[8]; data[8] = swap; }
    if (data[4] > data[9]) { swap = data[4]; data[4] = data[9]; data[9] = swap; }
    if (data[0] > data[3]) { swap = data[0]; data[0] = data[3]; data[3] = swap; }
    if (data[5] > data[8]) { swap = data[5]; data[5] = data[8]; data[8] = swap; }
    if (data[1] > data[4]) { swap = data[1]; data[1] = data[4]; data[4] = swap; }
    if (data[6] > data[9]) { swap = data[6]; data[6] = data[9]; data[9] = swap; }
    if (data[0] > data[2]) { swap = data[0]; data[0] = data[2]; data[2] = swap; }
    if (data[3] > data[6]) { swap = data[3]; data[3] = data[6]; data[6] = swap; }
    if (data[7] > data[9]) { swap = data[7]; data[7] = data[9]; data[9] = swap; }
    if (data[0] > data[1]) { swap = data[0]; data[0] = data[1]; data[1] = swap; }
    if (data[2] > data[4]) { swap = data[2]; data[2] = data[4]; data[4] = swap; }
    if (data[5] > data[7]) { swap = data[5]; data[5] = data[7]; data[7] = swap; }
    if (data[8] > data[9]) { swap = data[8]; data[8] = data[9]; data[9] = swap; }
    if (data[1] > data[2]) { swap = data[1]; data[1] = data[2]; data[2] = swap; }
    if (data[3] > data[5]) { swap = data[3]; data[3] = data[5]; data[5] = swap; }
    if (data[4] > data[6]) { swap = data[4]; data[4] = data[6]; data[6] = swap; }
    if (data[7] > data[8]) { swap = data[7]; data[7] = data[8]; data[8] = swap; }
    if (data[1] > data[3]) { swap = data[1]; data[1] = data[3]; data[3] = swap; }
    if (data[4] > data[7]) { swap = data[4]; data[4] = data[7]; data[7] = swap; }
    if (data[2] > data[5]) { swap = data[2]; data[2] = data[5]; data[5] = swap; }
    if (data[6] > data[8]) { swap = data[6]; data[6] = data[8]; data[8] = swap; }
    if (data[2] > data[3]) { swap = data[2]; data[2] = data[3]; data[3] = swap; }
    if (data[4] > data[5]) { swap = data[4]; data[4] = data[5]; data[5] = swap; }
    if (data[6] > data[7]) { swap = data[6]; data[6] = data[7]; data[7] = swap; }
    if (data[3] > data[4]) { swap = data[3]; data[3] = data[4]; data[4] = swap; }
    if (data[5] > data[6]) { swap = data[5]; data[5] = data[6]; data[6] = swap; }
    return(data);
}

alert(sortNet10([5,7,1,8,4,3,6,9,2,0]));

＆＃13;

这是网络的图形表示，分为独立的阶段
为了利用并行处理，可以将5-4-3-4-4-4-3-2分组改为4-4-4-4-4-4-3-2分组。

Answer 2

当您处理此固定大小时，请查看Sorting Networks。这些算法具有固定的运行时间，并且与其输入无关。对于您的用例，您不会遇到某些排序算法的开销。

Bitonic sort是此类网络的实现。这个在CPU上使用len（n）＆lt; = 32时效果最佳。在更大的输入上，您可以考虑转移到GPU。 https://en.wikipedia.org/wiki/Sorting_network

顺便说一下，比较排序算法的好页面就在这里（虽然它缺少bitonic sort。

http://www.sorting-algorithms.com

Answer 3

使用具有4个组比较的排序网络，因此您可以在SIMD寄存器中执行此操作。一对压缩的最小/最大指令实现了压缩比较器功能。抱歉，我现在没有时间寻找一个我记得看过这个页面的页面，但希望在SIMD或SSE排序网络上搜索会有所改善。

x86 SSE确实具有针对四个32位整数的向量的32位整数最小和最大指令。 AVX2（Haswell和更高版本）具有相同的但是对于具有8个整数的256b向量。还有高效的随机指示。

如果你有很多独立的小种类，可以使用向量并行进行4或8种排序。 ESP。如果您随机选择元素（因此要分类的数据无论如何都不会在内存中连续），您可以避免随机播放，只需按照您需要的顺序进行比较。 10个寄存器用于保存4个（AVX2：8）10个整数列表中的所有数据，但仍留有6个用于临时空间的reg。

如果您还需要对关联数据进行排序，则矢量排序网络效率较低。在这种情况下，最有效的方法似乎是使用packed-compare来获取哪些元素被更改的掩码，并使用该掩码来混合（引用）相关数据的向量。

Answer 4

展开的无分支选择排序怎么样？

#include <iostream>
#include <algorithm>
#include <random>

//return the index of the minimum element in array a
int min(const int * const a) {
  int m = a[0];
  int indx = 0;
  #define TEST(i) (m > a[i]) && (m = a[i], indx = i ); 
  //see http://stackoverflow.com/a/7074042/2140449
  TEST(1);
  TEST(2);
  TEST(3);
  TEST(4);
  TEST(5);
  TEST(6);
  TEST(7);
  TEST(8);
  TEST(9);
  #undef TEST
  return indx;
}

void sort( int * const a ){
  int work[10];
  int indx;
  #define GET(i) indx = min(a); work[i] = a[indx]; a[indx] = 2147483647; 
  //get the minimum, copy it to work and set it at max_int in a
  GET(0);
  GET(1);
  GET(2);
  GET(3);
  GET(4);
  GET(5);
  GET(6);
  GET(7);
  GET(8);
  GET(9);
  #undef GET
  #define COPY(i) a[i] = work[i];
  //copy back to a
  COPY(0);
  COPY(1);
  COPY(2);
  COPY(3);
  COPY(4);
  COPY(5);
  COPY(6);
  COPY(7);
  COPY(8);
  COPY(9);
  #undef COPY
}

int main() {
  //generating and printing a random array
  int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
  std::random_device rd;
  std::mt19937 g(rd());
  std::shuffle( a, a+10, g);
  for (int i = 0; i < 10; i++) {
    std::cout << a[i] << ' ';
  }
  std::cout << std::endl;

  //sorting and printing again
  sort(a);
  for (int i = 0; i < 10; i++) {
    std::cout << a[i] << ' ';
  } 

  return 0;
}

http://coliru.stacked-crooked.com/a/71e18bc4f7fa18c6

唯一相关的行是前两个#define。

它使用两个列表并完全重新检查第一个列表十次，这将是一个严格实现的选择排序，但它避免了分支和可变长度循环，这可能会补偿现代处理器和如此小的数据集。

基准

我对排序网络进行了基准测试，我的代码似乎更慢了。但是我试图删除展开和副本。运行此代码：

#include <iostream>
#include <algorithm>
#include <random>
#include <chrono>

int min(const int * const a, int i) {
  int m = a[i];
  int indx = i++;
  for ( ; i<10; i++) 
    //see http://stackoverflow.com/a/7074042/2140449
    (m > a[i]) && (m = a[i], indx = i ); 
  return indx;
}

void sort( int * const a ){
  for (int i = 0; i<9; i++)
    std::swap(a[i], a[min(a,i)]); //search only forward
}


void sortNet10(int * const data) {  // ten-input sorting network by Waksman, 1969
    int swap;
    if (data[0] > data[5]) { swap = data[0]; data[0] = data[5]; data[5] = swap; }
    if (data[1] > data[6]) { swap = data[1]; data[1] = data[6]; data[6] = swap; }
    if (data[2] > data[7]) { swap = data[2]; data[2] = data[7]; data[7] = swap; }
    if (data[3] > data[8]) { swap = data[3]; data[3] = data[8]; data[8] = swap; }
    if (data[4] > data[9]) { swap = data[4]; data[4] = data[9]; data[9] = swap; }
    if (data[0] > data[3]) { swap = data[0]; data[0] = data[3]; data[3] = swap; }
    if (data[5] > data[8]) { swap = data[5]; data[5] = data[8]; data[8] = swap; }
    if (data[1] > data[4]) { swap = data[1]; data[1] = data[4]; data[4] = swap; }
    if (data[6] > data[9]) { swap = data[6]; data[6] = data[9]; data[9] = swap; }
    if (data[0] > data[2]) { swap = data[0]; data[0] = data[2]; data[2] = swap; }
    if (data[3] > data[6]) { swap = data[3]; data[3] = data[6]; data[6] = swap; }
    if (data[7] > data[9]) { swap = data[7]; data[7] = data[9]; data[9] = swap; }
    if (data[0] > data[1]) { swap = data[0]; data[0] = data[1]; data[1] = swap; }
    if (data[2] > data[4]) { swap = data[2]; data[2] = data[4]; data[4] = swap; }
    if (data[5] > data[7]) { swap = data[5]; data[5] = data[7]; data[7] = swap; }
    if (data[8] > data[9]) { swap = data[8]; data[8] = data[9]; data[9] = swap; }
    if (data[1] > data[2]) { swap = data[1]; data[1] = data[2]; data[2] = swap; }
    if (data[3] > data[5]) { swap = data[3]; data[3] = data[5]; data[5] = swap; }
    if (data[4] > data[6]) { swap = data[4]; data[4] = data[6]; data[6] = swap; }
    if (data[7] > data[8]) { swap = data[7]; data[7] = data[8]; data[8] = swap; }
    if (data[1] > data[3]) { swap = data[1]; data[1] = data[3]; data[3] = swap; }
    if (data[4] > data[7]) { swap = data[4]; data[4] = data[7]; data[7] = swap; }
    if (data[2] > data[5]) { swap = data[2]; data[2] = data[5]; data[5] = swap; }
    if (data[6] > data[8]) { swap = data[6]; data[6] = data[8]; data[8] = swap; }
    if (data[2] > data[3]) { swap = data[2]; data[2] = data[3]; data[3] = swap; }
    if (data[4] > data[5]) { swap = data[4]; data[4] = data[5]; data[5] = swap; }
    if (data[6] > data[7]) { swap = data[6]; data[6] = data[7]; data[7] = swap; }
    if (data[3] > data[4]) { swap = data[3]; data[3] = data[4]; data[4] = swap; }
    if (data[5] > data[6]) { swap = data[5]; data[5] = data[6]; data[6] = swap; }
}


std::chrono::duration<double> benchmark( void(*func)(int * const), const int seed ) {
  std::mt19937 g(seed);
  int a[10] = {10,11,12,13,14,15,16,17,18,19};
  std::chrono::high_resolution_clock::time_point t1, t2; 
  t1 = std::chrono::high_resolution_clock::now();
  for (long i = 0; i < 1e7; i++) {
    std::shuffle( a, a+10, g);
    func(a);
  }
  t2 = std::chrono::high_resolution_clock::now();
  return std::chrono::duration_cast<std::chrono::duration<double>>(t2 - t1);
}

int main() {
  std::random_device rd;
  for (int i = 0; i < 10; i++) {
    const int seed = rd();
    std::cout << "seed = " << seed << std::endl;
    std::cout << "sortNet10: " << benchmark(sortNet10, seed).count() << std::endl;
    std::cout << "sort:      " << benchmark(sort,      seed).count() << std::endl;
  }
  return 0;
}

与分拣网络相比，我一直获得更好的无分支选择排序结果。

$ gcc -v
gcc version 5.2.0 (GCC) 
$ g++ -std=c++11 -Ofast sort.cpp && ./a.out
seed = -1727396418
sortNet10: 2.24137
sort:      2.21828
seed = 2003959850
sortNet10: 2.23914
sort:      2.21641
seed = 1994540383
sortNet10: 2.23782
sort:      2.21778
seed = 1258259982
sortNet10: 2.25199
sort:      2.21801
seed = 1821086932
sortNet10: 2.25535
sort:      2.2173
seed = 412262735
sortNet10: 2.24489
sort:      2.21776
seed = 1059795817
sortNet10: 2.29226
sort:      2.21777
seed = -188551272
sortNet10: 2.23803
sort:      2.22996
seed = 1043757247
sortNet10: 2.2503
sort:      2.23604
seed = -268332483
sortNet10: 2.24455
sort:      2.24304

Answer 5

问题并不是说这是某种基于网络的应用程序。引起我注意的一件事是：

我正在对数十亿个元素的数据集进行采样，每次我需要从中挑选10个数字（简化）并对它们进行排序（并从排序的10个元素列表中得出结论）。

作为一名软件和硬件工程师，这对我来说绝对是尖叫的“强”>“FPGA”。我不知道你需要从排序的数字集中得出什么样的结论，或者数据来自哪里，但我知道在一亿到十亿之间处理之间几乎是微不足道的这些“排序和分析”操作每秒。我以前做过FPGA辅助的DNA测序工作。当问题非常适合这种类型的解决方案时，几乎不可能击败FPGA的大量处理能力。

在某种程度上，唯一的限制因素是您可以多快地将数据转移到FPGA中以及获取它的速度有多快。

作为参考，我设计了一个高性能的实时图像处理器，以每秒约3亿像素的速率接收32位RGB图像数据。在从另一端出来之前，数据通过FIR滤波器，矩阵乘法器，查找表，空间边缘检测块和许多其他操作进行流式传输。所有这一切都在一个相对较小的Xilinx Virtex2 FPGA上，内部时钟范围从大约33MHz到如果我没记错，400MHz。哦，是的，它还有一个DDR2控制器实现并运行了两组DDR2内存。

FPGA可以在每个时钟转换时输出一个10位32位数，同时工作在数百MHz。当数据填满处理管道时，在操作开始时会有短暂的延迟。之后，您应该能够每个时钟获得一个结果。或者更多，如果可以通过复制排序和分析管道来并行化处理。原则上，解决方案几乎是微不足道的。

重点是：如果应用程序不受PC限制且数据流和处理与FPGA解决方案“兼容”（独立或作为机器中的协处理器卡），则没有办法无论算法如何，您都可以用任何语言编写的软件来达到可达到的性能水平。

修改

只是快速搜索并找到了可能对您有用的文章。看起来它可以追溯到2012年。今天你可以做得更好（甚至当时）。这是：

Sorting Networks on FPGAs

Answer 6

我最近写了一个little class，它使用Bose-Nelson算法在编译时生成排序网络。

它可用于为10个数字创建非常快速的排序。

/**
 * A Functor class to create a sort for fixed sized arrays/containers with a
 * compile time generated Bose-Nelson sorting network.
 * \tparam NumElements  The number of elements in the array or container to sort.
 * \tparam T            The element type.
 * \tparam Compare      A comparator functor class that returns true if lhs < rhs.
 */
template <unsigned NumElements, class Compare = void> class StaticSort
{
    template <class A, class C> struct Swap
    {
        template <class T> inline void s(T &v0, T &v1)
        {
            T t = Compare()(v0, v1) ? v0 : v1; // Min
            v1 = Compare()(v0, v1) ? v1 : v0; // Max
            v0 = t;
        }

        inline Swap(A &a, const int &i0, const int &i1) { s(a[i0], a[i1]); }
    };

    template <class A> struct Swap <A, void>
    {
        template <class T> inline void s(T &v0, T &v1)
        {
            // Explicitly code out the Min and Max to nudge the compiler
            // to generate branchless code.
            T t = v0 < v1 ? v0 : v1; // Min
            v1 = v0 < v1 ? v1 : v0; // Max
            v0 = t;
        }

        inline Swap(A &a, const int &i0, const int &i1) { s(a[i0], a[i1]); }
    };

    template <class A, class C, int I, int J, int X, int Y> struct PB
    {
        inline PB(A &a)
        {
            enum { L = X >> 1, M = (X & 1 ? Y : Y + 1) >> 1, IAddL = I + L, XSubL = X - L };
            PB<A, C, I, J, L, M> p0(a);
            PB<A, C, IAddL, J + M, XSubL, Y - M> p1(a);
            PB<A, C, IAddL, J, XSubL, M> p2(a);
        }
    };

    template <class A, class C, int I, int J> struct PB <A, C, I, J, 1, 1>
    {
        inline PB(A &a) { Swap<A, C> s(a, I - 1, J - 1); }
    };

    template <class A, class C, int I, int J> struct PB <A, C, I, J, 1, 2>
    {
        inline PB(A &a) { Swap<A, C> s0(a, I - 1, J); Swap<A, C> s1(a, I - 1, J - 1); }
    };

    template <class A, class C, int I, int J> struct PB <A, C, I, J, 2, 1>
    {
        inline PB(A &a) { Swap<A, C> s0(a, I - 1, J - 1); Swap<A, C> s1(a, I, J - 1); }
    };

    template <class A, class C, int I, int M, bool Stop = false> struct PS
    {
        inline PS(A &a)
        {
            enum { L = M >> 1, IAddL = I + L, MSubL = M - L};
            PS<A, C, I, L, (L <= 1)> ps0(a);
            PS<A, C, IAddL, MSubL, (MSubL <= 1)> ps1(a);
            PB<A, C, I, IAddL, L, MSubL> pb(a);
        }
    };

    template <class A, class C, int I, int M> struct PS <A, C, I, M, true>
    {
        inline PS(A &a) {}
    };

public:
    /**
     * Sorts the array/container arr.
     * \param  arr  The array/container to be sorted.
     */
    template <class Container> inline void operator() (Container &arr) const
    {
        PS<Container, Compare, 1, NumElements, (NumElements <= 1)> ps(arr);
    };

    /**
     * Sorts the array arr.
     * \param  arr  The array to be sorted.
     */
    template <class T> inline void operator() (T *arr) const
    {
        PS<T*, Compare, 1, NumElements, (NumElements <= 1)> ps(arr);
    };
};

#include <iostream>
#include <vector>

int main(int argc, const char * argv[])
{
    enum { NumValues = 10 };

    // Arrays
    {
        int rands[NumValues];
        for (int i = 0; i < NumValues; ++i) rands[i] = rand() % 100;
        std::cout << "Before Sort: \t";
        for (int i = 0; i < NumValues; ++i) std::cout << rands[i] << " ";
        std::cout << "\n";
        StaticSort<NumValues> staticSort;
        staticSort(rands);
        std::cout << "After Sort: \t";
        for (int i = 0; i < NumValues; ++i) std::cout << rands[i] << " ";
        std::cout << "\n";
    }

    std::cout << "\n";

    // STL Vector
    {
        std::vector<int> rands(NumValues);
        for (int i = 0; i < NumValues; ++i) rands[i] = rand() % 100;
        std::cout << "Before Sort: \t";
        for (int i = 0; i < NumValues; ++i) std::cout << rands[i] << " ";
        std::cout << "\n";
        StaticSort<NumValues> staticSort;
        staticSort(rands);
        std::cout << "After Sort: \t";
        for (int i = 0; i < NumValues; ++i) std::cout << rands[i] << " ";
        std::cout << "\n";
    }

    return 0;
}

请注意，我们为min和max明确编写了三元运算符，而不是if (compare) swap语句。这是为了帮助推动编译器使用无分支代码。

基准

以下基准测试用clang -O3编译并在我2012年中期的macbook air上运行。

对随机数据进行排序

将其与DarioP的代码进行比较，以下是对100万个大小为10的32位int数组进行排序所需的毫秒数：

硬编码排序网10： 88.774 ms
模板化Bose-Nelson排序10： 27.815 ms

使用这种模板化方法，我们还可以在编译时为其他数量的元素生成排序网络。

对100万种不同大小的数组进行排序的时间（以毫秒为单位）大小为2,4,8的数组的毫秒数分别为1.943,8.655,20.246 C++ Templated Bose-Nelson Static Sort timings

对展开的插入排序，Glenn Teitelbaum的积分。

以下是6个元素的小数组的每种平均时钟数。基准代码和示例可以在这个问题上找到：
Fastest sort of fixed length 6 int array

Direct call to qsort library function       : 326.81
Naive implementation (insertion sort)       : 132.98
Insertion Sort (Daniel Stutzbach)           : 104.04
Insertion Sort Unrolled                     : 99.64
Insertion Sort Unrolled (Glenn Teitelbaum)  : 81.55
Rank Order                                  : 44.01
Rank Order with registers                   : 42.40
Sorting Networks (Daniel Stutzbach)         : 88.06
Sorting Networks (Paul R)                   : 31.64
Sorting Networks 12 with Fast Swap          : 29.68
Sorting Networks 12 reordered Swap          : 28.61
Reordered Sorting Network w/ fast swap      : 24.63
Templated Sorting Network (this class)      : 25.37

它的效果与6个元素的问题中最快的例子一样快。

排序分类数据的性能

通常，输入数组可能已经排序或大部分已排序在这种情况下，插入排序可以是更好的选择。

您可能希望根据数据选择合适的排序算法。

可以找到用于基准测试的代码here。

Answer 7

您可以完全展开insertion sort

为了使这更容易，递归template可以在没有函数开销的情况下使用。由于它已经是template，int也可以是template参数。这也使得编码数组大小不是10平凡的。

请注意，要对int x[10]进行排序，调用为insert_sort<int, 9>::sort(x);，因为该类使用最后一项的索引。这可以包装，但这将是更多的代码来阅读。

template <class T, int NUM>
class insert_sort;

template <class T>
class insert_sort<T,0>
// stop template recursion
// sorting 1 item is a no-op
{
public:
    static void place(T *x) {}
    static void sort(T * x) {}
};

template <class T, int NUM>
class insert_sort
// use template recursion to do insertion sort
// NUM is the index of the last item, eg. for x[10] call <9>
{
public:
    static void place(T *x)
    {
        T t1=x[NUM-1];
        T t2=x[NUM];
        if (t1 > t2)
        {
            x[NUM-1]=t2;
            x[NUM]=t1;
            insert_sort<T,NUM-1>::place(x);
        }
    }
    static void sort(T * x)
    {
        insert_sort<T,NUM-1>::sort(x); // sort everything before
        place(x);                    // put this item in
    }
};

在我的测试中，这比排序网络示例更快。

Answer 8

插入排序平均需要29,6次比较才能对10个输入进行排序，最佳情况为9，最差情况为45（给定输入的顺序相反）。

{9,6,1}炮弹将平均需要25.5次比较才能对10个输入进行排序。最好的情况是14次比较，最差的是34次，并且对反向输入进行排序需要22次。

因此，使用shellsort而不是插入排序可将平均情况减少14％。尽管最佳情况增加了56％，但最坏情况下减少了24％，这在保持最差情况下的性能非常重要的应用中非常重要。相反的情况减少了51％。

由于您似乎熟悉插入排序，因此您可以将算法实现为{9,6}的排序网络，然后在插入排序（{1}）之后添加：

i[0] with i[9]    // {9}

i[0] with i[6]    // {6}
i[1] with i[7]    // {6}
i[2] with i[8]    // {6}
i[3] with i[9]    // {6}

i[0 ... 9]        // insertion sort

Answer 9

由于与我所描述的here类似的原因，以下排序功能gcloud auth application-default login和sort6_iterator()应该效果良好，排序网络来自here ：

sort10_iterator_local()

要调用此函数，我将它传递给template<class IterType> inline void sort10_iterator(IterType it) { #define SORT2(x,y) {if(data##x>data##y)std::swap(data##x,data##y);} #define DD1(a) auto data##a=*(data+a); #define DD2(a,b) auto data##a=*(data+a), data##b=*(data+b); #define CB1(a) *(data+a)=data##a; #define CB2(a,b) *(data+a)=data##a;*(data+b)=data##b; DD2(1,4) SORT2(1,4) DD2(7,8) SORT2(7,8) DD2(2,3) SORT2(2,3) DD2(5,6) SORT2(5,6) DD2(0,9) SORT2(0,9) SORT2(2,5) SORT2(0,7) SORT2(8,9) SORT2(3,6) SORT2(4,9) SORT2(0,1) SORT2(0,2) CB1(0) SORT2(6,9) CB1(9) SORT2(3,5) SORT2(4,7) SORT2(1,8) SORT2(3,4) SORT2(5,8) SORT2(6,7) SORT2(1,2) SORT2(7,8) CB1(8) SORT2(1,3) CB1(1) SORT2(2,5) SORT2(4,6) SORT2(2,3) CB1(2) SORT2(6,7) CB1(7) SORT2(4,5) SORT2(3,4) CB2(3,4) SORT2(5,6) CB2(5,6) #undef CB1 #undef CB2 #undef DD1 #undef DD2 #undef SORT2 }迭代器。

Answer 10

为什么可以调动时调动？一个x86缓存行具有足够的额外内存供您进行合并排序。

我可能会分别插入排序索引0-1、2-4、5-6、7-9，或者甚至最好像插入时那样对这些小组进行排序，以便每个插入最多需要一个或两个移位。

然后合并5,6和7-9-> 10-14，合并0-1和2-4-> 5-9，最后合并5-9和10-14-> 0-9

排序10个数字的最快方法？（数字是32位）

10 个答案:

基准

基准

对随机数据进行排序

排序分类数据的性能

排序10个数字的最快方法？ （数字是32位）

10 个答案:

基准

基准

对随机数据进行排序

排序分类数据的性能

排序10个数字的最快方法？（数字是32位）