Saya memecahkan masalah dan itu melibatkan pengurutan 10 angka (int32) dengan sangat cepat. Aplikasi saya perlu mengurutkan 10 angka jutaan kali secepat mungkin. Saya mengambil sampel sekumpulan miliaran elemen dan setiap kali saya harus memilih 10 angka darinya (disederhanakan) dan mengurutkannya (dan membuat kesimpulan dari daftar 10 elemen yang diurutkan).

Saat ini saya menggunakan jenis penyisipan tapi saya membayangkan saya bisa menerapkan algoritma penyortiran khusus yang sangat cepat untuk masalah spesifik saya 10 angka yang akan mengalahkan jenis penyisipan.

Adakah yang tahu cara mendekati masalah ini?

(Menindaklanjuti saran HelloWorld untuk melihat ke jaringan penyortiran.)

Tampaknya jaringan 29-perbandingan / swap adalah cara tercepat untuk melakukan semacam 10-input. Saya menggunakan jaringan yang ditemukan oleh Waksman pada tahun 1969 untuk contoh ini dalam Javascript, yang seharusnya diterjemahkan langsung ke C, karena itu hanya daftar ifpernyataan, perbandingan, dan swap.

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

Berikut ini adalah representasi grafis dari jaringan, dibagi menjadi beberapa fase independen. Untuk memanfaatkan pemrosesan paralel, pengelompokan 5-4-3-4-4-4-3-2 dapat diubah menjadi pengelompokan 4-4-4-4-4-4-3-2.

Saat Anda menangani ukuran tetap ini, lihat Sorting Networks . Algoritma ini memiliki runtime yang tetap dan independen terhadap inputnya. Untuk kasus penggunaan Anda, Anda tidak memiliki overhead seperti yang memiliki beberapa algoritma penyortiran.

Sortasi Bitonic adalah implementasi dari jaringan tersebut. Yang ini bekerja paling baik dengan len (n) <= 32 pada CPU. Pada input yang lebih besar Anda bisa berpikir untuk pindah ke GPU. https://en.wikipedia.org/wiki/Sorting_network

Btw, halaman yang bagus untuk membandingkan algoritme pengurutan ada di sini (meskipun tidak ada bitonic sort.

http://www.sorting-algorithms.com

Gunakan jaringan penyortiran yang memiliki perbandingan dalam kelompok 4, sehingga Anda dapat melakukannya di register SIMD. Sepasang instruksi min / maks yang dikemas mengimplementasikan fungsi pembanding yang dikemas. Maaf saya tidak punya waktu sekarang untuk mencari halaman yang saya ingat pernah melihat ini, tetapi mudah-mudahan mencari di jaringan penyortiran SIMD atau SSE akan mengubah sesuatu.

x86 SSE memang memiliki instruksi min dan max integer 32bit-integer untuk vektor empat int 32bit. AVX2 (Haswell dan yang lebih baru) memiliki vektor yang sama tetapi untuk 256b dari 8 int. Ada juga instruksi pengocokan yang efisien.

Jika Anda memiliki banyak jenis kecil yang independen, dimungkinkan untuk melakukan 4 atau 8 jenis secara paralel menggunakan vektor. Esp. jika Anda memilih elemen secara acak (sehingga data yang akan disortir tidak akan bersebelahan dalam memori), Anda dapat menghindari kerutan dan cukup membandingkan dalam urutan yang Anda butuhkan. 10 register untuk menampung semua data dari 4 (AVX2: 8) daftar 10 int masih menyisakan 6 regs untuk ruang awal.

Jaringan sortir vektor kurang efisien jika Anda juga perlu mengurutkan data terkait. Dalam hal itu, cara yang paling efisien tampaknya menggunakan perbandingan-bungkus untuk mendapatkan topeng yang elemennya berubah, dan menggunakan topeng itu untuk mencampur vektor (referensi ke) data terkait.

Bagaimana dengan jenis pemilihan yang tidak terbuka, kurang cabang?

#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

Satu-satunya garis yang relevan adalah dua yang pertama #define.

Ini menggunakan dua daftar dan sepenuhnya memeriksa kembali yang pertama untuk sepuluh kali yang akan menjadi semacam pemilihan yang diimplementasikan dengan buruk, namun itu menghindari cabang dan loop panjang variabel, yang dapat mengimbangi dengan prosesor modern dan seperangkat data kecil.

Tolok ukur

Saya membandingkan dengan jaringan penyortiran, dan kode saya tampaknya lebih lambat. Namun saya mencoba untuk menghapus membuka gulungan dan salinannya. Menjalankan kode ini:

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

Saya secara konsisten mendapatkan hasil yang lebih baik untuk jenis pemilihan kurang cabang dibandingkan dengan jaringan penyortiran.

$ 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

Pertanyaannya tidak mengatakan bahwa ini adalah semacam aplikasi berbasis web. Satu hal yang menarik perhatian saya adalah:

Saya mengambil sampel sekumpulan miliaran elemen dan setiap kali saya harus memilih 10 angka darinya (disederhanakan) dan mengurutkannya (dan membuat kesimpulan dari daftar 10 elemen yang diurutkan).

Sebagai seorang insinyur perangkat lunak dan perangkat keras ini benar-benar berteriak "FPGA" kepada saya. Saya tidak tahu kesimpulan apa yang perlu Anda ambil dari kumpulan angka yang diurutkan atau dari mana data berasal tetapi saya tahu hampir sepele untuk memproses di suatu tempat antara seratus juta dan satu miliar dari "sort-and-" ini menganalisis "operasi per detik . Saya telah melakukan pekerjaan sekuensing DNA yang dibantu FPGA di masa lalu. Hampir tidak mungkin untuk mengalahkan kekuatan pemrosesan besar-besaran dari FPGA ketika masalahnya cocok untuk jenis solusi.

Pada tingkat tertentu, satu-satunya faktor pembatas adalah seberapa cepat Anda dapat menyekop data menjadi FPGA dan seberapa cepat Anda bisa mengeluarkannya.

Sebagai referensi, saya merancang prosesor gambar real-time berkinerja tinggi yang menerima data gambar RGB 32 bit dengan kecepatan sekitar 300 juta piksel per detik. Data mengalir melalui filter FIR, pengganda matriks, tabel pencarian, blok deteksi tepi spasial dan sejumlah operasi lainnya sebelum keluar dari ujung lainnya. Semua ini pada Xilinx Virtex2 FPGA yang relatif kecil dengan clocking internal berkisar dari sekitar 33MHz hingga, jika saya ingat dengan benar, 400MHz. Oh, ya, itu juga memiliki implementasi kontroler DDR2 dan menjalankan dua bank memori DDR2.

Sebuah FPGA dapat menghasilkan semacam angka sepuluh 32 bit pada setiap transisi jam saat beroperasi pada ratusan MHz. Akan ada penundaan singkat di awal operasi karena data mengisi pipa pemrosesan. Setelah itu Anda harus bisa mendapatkan satu hasil per jam. Atau lebih jika pemrosesan dapat diparalelkan dengan mereplikasi pipa sort-and-analysis. Solusinya, pada prinsipnya, hampir sepele.

Intinya adalah: Jika aplikasi tidak terikat PC dan aliran data dan pemrosesan "kompatibel" dengan solusi FPGA (baik berdiri sendiri atau sebagai kartu co-prosesor di mesin) tidak ada cara Anda pergi untuk dapat mengalahkan tingkat kinerja yang dapat dicapai dengan perangkat lunak yang ditulis dalam bahasa apa pun, terlepas dari algoritma.

EDIT:

Cukup jalankan pencarian cepat dan temukan kertas yang mungkin berguna bagi Anda. Sepertinya tanggal kembali ke 2012. Anda dapat melakukan BANYAK lebih baik dalam kinerja hari ini (dan bahkan saat itu). Ini dia:

Menyortir Jaringan pada FPGA

Baru-baru ini saya menulis sebuah kelas kecil yang menggunakan algoritma Bose-Nelson untuk menghasilkan jaringan sortir pada waktu kompilasi.

Ini dapat digunakan untuk membuat sort yang sangat cepat untuk 10 angka.

/**
 * 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;
}

Perhatikan bahwa alih-alih if (compare) swappernyataan, kami secara eksplisit memberi kode pada operator ternary untuk min dan maks. Ini untuk membantu mendorong kompiler menggunakan kode branchless.

Tolak ukur

Tolok ukur berikut dikompilasi dengan dentang -O3 dan berjalan pada pertengahan 2012 macbook air saya.

Menyortir data acak

Membandingkannya dengan kode DarioP, berikut adalah jumlah milidetik yang diambil untuk mengurutkan 1 juta array int 32-bit ukuran 10:

Hardcoded Sort Net 10: 88.774 ms
Templated Bose-Nelson sort 10: 27.815 ms

Menggunakan pendekatan templated ini, kita juga dapat menghasilkan jaringan sortir pada waktu kompilasi untuk sejumlah elemen lainnya.

Waktu (dalam milidetik) untuk mengurutkan 1 juta array dari berbagai ukuran.
Jumlah milidetik untuk array ukuran 2, 4, 8 masing-masing adalah 1.943, 8.655, 20.246.

Penghargaan untuk Glenn Teitelbaum untuk jenis penyisipan yang tidak gulungan.

Berikut adalah jam rata-rata per sort untuk array kecil dari 6 elemen. Kode dan contoh benchmark dapat ditemukan pada pertanyaan ini:
Jenis tercepat dari array dengan panjang tetap 6 int

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

Ia melakukan secepat contoh tercepat dalam pertanyaan untuk 6 elemen.

Kinerja untuk menyortir data yang diurutkan

Seringkali, array input mungkin sudah diurutkan atau sebagian besar diurutkan.
Dalam kasus seperti itu, jenis penyisipan bisa menjadi pilihan yang lebih baik.

Anda mungkin ingin memilih algoritma pengurutan yang sesuai tergantung pada data.

Kode yang digunakan untuk tolok ukur dapat ditemukan di sini .

Meskipun jenis jaringan memiliki peluang bagus untuk menjadi cepat pada array kecil, kadang-kadang Anda tidak bisa mengalahkan jenis penyisipan jika dioptimalkan dengan benar. Misalnya memasukkan batch dengan 2 elemen:

{
    final int a=in[0]<in[1]?in[0]:in[1];
    final int b=in[0]<in[1]?in[1]:in[0];
    in[0]=a;
    in[1]=b;
}
for(int x=2;x<10;x+=2)
{
    final int a=in[x]<in[x+1]?in[x]:in[x+1];
    final int b=in[x]<in[x+1]?in[x+1]:in[x];
    int y= x-1;

    while(y>=0&&in[y]>b)
    {
        in[y+2]= in[y];
        --y;
    }
    in[y+2]=b;
    while(y>=0&&in[y]>a)
    {
        in[y+1]= in[y];
        --y;
    }
    in[y+1]=a;
}

Anda dapat membuka gulungan sepenuhnya insertion sort

Untuk membuatnya lebih mudah, rekursif template s dapat digunakan tanpa overhead fungsi. Karena sudah merupakan template, intbisa menjadi templateparameter juga. Ini juga membuat ukuran array pengkodean selain 10 sepele untuk dibuat.

Perhatikan bahwa untuk mengurutkan int x[10] panggilan adalah insert_sort<int, 9>::sort(x);karena kelas menggunakan indeks dari item terakhir. Ini bisa dibungkus, tetapi itu akan menjadi lebih banyak kode untuk dibaca.

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

Dalam pengujian saya ini lebih cepat daripada contoh jaringan penyortiran.

Untuk alasan yang mirip dengan yang saya jelaskan di sini , fungsi penyortiran berikut, sort6_iterator()dan sort10_iterator_local(), harus berkinerja baik, di mana jaringan penyortiran diambil dari sini :

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
}

Untuk memanggil fungsi ini, saya melewatinya dengan std::vectoriterator.

Sortasi penyisipan membutuhkan perbandingan rata-rata 29,6 untuk mengurutkan 10 input dengan case terbaik 9 dan terburuk 45 (input yang diberikan dalam urutan terbalik).

Shellsort {9,6,1} akan membutuhkan perbandingan rata-rata 25,5 untuk mengurutkan 10 input. Kasus terbaik adalah 14 perbandingan, terburuk adalah 34 dan menyortir input terbalik memerlukan 22.

Jadi menggunakan shellsort sebagai ganti insertion mengurangi rata-rata case sebesar 14%. Meskipun kasus terbaik meningkat sebesar 56%, kasus terburuk berkurang sebesar 24% yang signifikan dalam aplikasi di mana menjaga kinerja kasus terburuk dalam pemeriksaan adalah penting. Kasus terbalik dikurangi 51%.

Karena Anda sepertinya terbiasa dengan jenis penyisipan, Anda dapat mengimplementasikan algoritma sebagai jaringan penyortiran untuk {9,6} dan kemudian menempelkan jenis penyisipan ({1}) setelah itu:

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