Dalam artikel terakhir, kami berkenalan dengan jenis relik penggabungan (menyebabkan kepentingan sejarah utama). Apa tren hari ini?

Untuk membiasakan diri dengan konsep pemesanan melalui merger, biasanya digunakan algoritma gabungan seimbang. Istilah "keseimbangan" berarti bahwa algoritma secara rekursif membagi array dan sub-arraynya menjadi bagian yang kira-kira sama. Hari ini kita melihat bagaimana tampilannya dalam praktik.

Sepasang fungsi adalah sama untuk kedua metode. Ngomong-ngomong, "down-up" itu, "up-down" itu adalah algoritma yang hampir sama, hanya ditunjukkan dari sudut yang berbeda.

Kita perlu, pada kenyataannya, penggabungan dua bagian segmen menjadi satu subarray. Bagian dibagi secara bersamaan dalam satu array, elemen saat ini di kedua iterasi dibandingkan dan elemen yang lebih kecil masuk ke array kedua:

//   A[iBegin: iMiddle - 1] //   A[iMiddle: iEnd - 1] //:   B[iBegin: iEnd - 1] void Merge(A[], iBegin, iMiddle, iEnd, B[]) { i = iBegin, j = iMiddle; //       ... for (k = iBegin; k < iEnd; k++) { //     //  <=    if (i < iMiddle && (j >= iEnd || A[i] <= A[j])) { B[k] = A[i]; i++; } else { B[k] = A[j]; j++; } } } 

Menyalin segmen dari satu array ke array lainnya. Kedua implementasi beroperasi pada dua array, data harus terus didorong dari main ke auxiliary dan sebaliknya:

 //    A[] //   B[] void CopyArray(A[], iBegin, iEnd, B[]) { for(k = iBegin; k < iEnd; k++) B[k] = A[k]; } 

Merger secara seimbang

Pertama, seluruh array diambil, setelah itu mulailah rekursif. Array didikotomikan sampai kita mencapai subarrays dari satu elemen (yang diurutkan sendiri). Kemudian rekursi memulai kenaikan terbalik, menggabungkan subarrays sepanjang jalan (ukurannya dua kali lipat pada setiap tingkat).

 //  A[]     // B[]   void TopDownMergeSort(A[], B[], n) { CopyArray(A, 0, n, B); // A[]  B[] TopDownSplitMerge(B, 0, n, A);// B[]    A[] } //    A[],  B[]    // : iBegin ; iEnd   void TopDownSplitMerge(B[], iBegin, iEnd, A[]) { // size == 1,     if(iEnd - iBegin < 2) return; // size > 1,     iMiddle = (iEnd + iBegin) / 2;//iMiddle -   //     A[]  B[] TopDownSplitMerge(A, iBegin, iMiddle, B);//   TopDownSplitMerge(A, iMiddle, iEnd, B);//   //    B[]  A[] Merge(B, iBegin, iMiddle, iEnd, A); } 

Merger Ke Atas yang Seimbang

Di sini iterasi atas array berlangsung, di sepanjang jalan pertama kita mengambil array minimal tetangga (dari satu elemen) dan menggabungkannya berpasangan. Setelah menggandakan subarrays yang diurutkan pada setiap langkah, kami menggabungkan tetangga lagi dan melanjutkan sampai kami mendapatkan seluruh array dalam bentuk diurutkan pada output.

 //  A[]     // B[]   void BottomUpMergeSort(A[], B[], n) { //      A[]  «». //    : //× 2, 4, 8, 16, ... -   ,       for (width = 1; width < n; width = 2 * width) { //     width for (i = 0; i < n; i = i + 2 * width) { //   : //A [i: i + width - 1]  A [i + width: i + 2 * width - 1]  B[] //  A[i: n - 1]  B[] ( i + width > = n) Merge(A, i, min(i + width, n), min(i + 2 * width, n), B); } //   B[]    2 * width //  B[]   A[]    //     A[]  B[] CopyArray(B, 0, n, A); // B[]  A[] //      2 * width } } 

Secara umum, implementasi top-down lebih disukai, karena menggunakan dua array lebih efisien, yang hanya terus-menerus mengubah peran "main / auxiliary". Dalam versi hulu, array A selalu primer, dan array B selalu tambahan. Akibatnya, setelah setiap iterasi, data dari B harus dikembalikan sepenuhnya ke A, yang tidak berkontribusi pada peningkatan kompleksitas algoritmik. Di sisi lain, implementasi ascendant lebih sederhana, bahkan tidak memiliki rekursi.

Merger yang tidak seimbang

Dari kata "keseimbangan" itu sendiri ia menghancurkan semacam keandalan, stabilitas. Anda bahkan mungkin mendapat kesan bahwa algoritma yang baik harus seimbang. Dan "ketidakseimbangan" dikaitkan dengan semacam kegoyahan dan distorsi. Well, sungguh, bukankah seharusnya yang seimbang lebih baik dalam semua hal daripada yang tidak seimbang ?

Faktanya, ini lebih buruk. Tentu saja, membagi subarrays menjadi bagian yang sama (yang dimaksud dengan keseimbangan untuk jenis penggabungan) jauh lebih mudah untuk diterapkan. Bagi diri Anda sendiri array menjadi dua dan terapkan rekursi untuk masing-masing setengah. Sebenarnya, kemudahan ini adalah keuntungan utama dari merger yang seimbang sebelum yang tidak seimbang.

Dalam publikasi berikut, kita akan melihat metode yang tidak seimbang. Mereka terasa lebih sulit untuk dipahami dan diimplementasikan. Data untuk penggabungan selanjutnya tidak akan didistribusikan secara merata dan merata di seluruh array bantu, tetapi sesuai dengan sejumlah angka Fibonacci umum. Dan ini akan memungkinkan Anda untuk mencapai hasil yang kuat yang tidak dapat dicapai untuk metode seimbang yang disederhanakan.

Referensi

Gabung ( Google-terjemahkan ), Gabung

Artikel Seri:

• Aplikasi Excel AlgoLab.xlsm
• Pertukaran macam
• Urutan Penyisipan
• Sortir berdasarkan pilihan
• Gabungkan Urusan
  
  • Merger top-down dan bottom-up yang seimbang
  • Sortasi Penggabungan Multi-fase
  • Cascading Merge Sort
  • Urutkan Gabung Berosilasi
  • Penyortiran berulir dan tidak bercampur
  • Gabungkan Sortir Perbandingan
• Urutkan berdasarkan distribusi
• Sortasi Hibrid

Penyortiran gabungan berikutnya sekarang tersedia di aplikasi AlgoLab (bagi mereka yang mempelajari algoritma menggunakan aplikasi Excel ini, perbarui file).

Array terbatas sementara - ukurannya harus dua kali lipat (karena beberapa kesulitan yang dihadapi saat pemrograman visualisasi). Beberapa saat kemudian akan dimungkinkan untuk mengurutkan array apa pun.

Artikel ini ditulis dengan dukungan Perangkat Lunak EDISON, sebuah perusahaan yang menggunakan layanan cloud untuk membuat perangkat lunak tertanam dan mengembangkan aplikasi seluler di JAVA .