Pertama pertimbangkan cara menggabungkan dua urutan terurut. Caranya sangat mudah, cukup bandingkan bilangan pertama dari dua barisan tersebut dan ambil bilangan yang lebih kecil terlebih dahulu. Setelah diambil, hapus bilangan pada barisan yang bersangkutan. Lalu bandingkan, jika salah satu kolomnya kosong, keluarkan saja data kolom lainnya satu per satu.
Copy kode kodenya sebagai berikut:
Lihat Kode
//Gabungkan array terurut a[] dan b[] ke dalam c[]
batal MemeryArray(int a[], int n, int b[], int m, int c[])
{
ke dalam aku, j, k;
saya = j = k = 0;
sementara (saya < n && j < m)
{
jika (sebuah[saya] < b[j])
c[k++] = a[i++];
kalau tidak
c[k++] = b[j++];
}
sementara (saya < n)
c[k++] = a[i++];
sementara (j <m)
c[k++] = b[j++];
}
Terlihat bahwa efisiensi penggabungan barisan terurut relatif tinggi dan dapat mencapai O(n).
Setelah menyelesaikan masalah penggabungan barisan terurut di atas, mari kita lihat pengurutan gabungan. Ide dasarnya adalah membagi array menjadi dua grup A dan B. Jika data dalam kedua grup ini semuanya terurut, maka dapat dengan mudah kedua himpunan ini. data diurutkan. Bagaimana cara agar data pada kedua kelompok ini tetap berurutan?
Grup A dan B dapat dibagi menjadi dua grup. Analoginya, jika suatu kelompok yang dipisahkan hanya mempunyai satu data, maka kelompok tersebut dianggap telah mencapai urutan, kemudian kedua kelompok yang berdekatan dapat digabungkan. Dengan cara ini, penyortiran gabungan diselesaikan dengan terlebih dahulu mendekomposisi array secara rekursif dan kemudian menggabungkan array.
Copy kode kodenya sebagai berikut:
Lihat Kode
//Akan menggabungkan dua urutan terurut a[pertama...pertengahan] dan a[pertengahan...terakhir].
void mergearray(int a[], int pertama, int pertengahan, int terakhir, int temp[])
{
int i = pertama, j = pertengahan + 1;
int m = pertengahan, n = terakhir;
ke dalam k = 0;
sementara (saya <= m && j <= n)
{
jika (a[i] <= a[j])
suhu[k++] = a[i++];
kalau tidak
suhu[k++] = a[j++];
}
sementara (saya <= m)
suhu[k++] = a[i++];
sementara (j <= n)
suhu[k++] = a[j++];
untuk (saya = 0; saya < k; saya++)
a[pertama + i] = suhu[i];
}
void mergesort(int a[], int pertama, int terakhir, int temp[])
{
jika (pertama < terakhir)
{
int pertengahan = (pertama + terakhir) / 2;
mergesort(a, first, mid, temp); //Sisi kiri diurutkan
mergesort(a, mid + 1, last, temp); //Sisi kanan sudah diurutkan
mergearray(a, first, mid, last, temp); //Menggabungkan dua array yang diurutkan
}
}
bool MergeSort(int a[], int n)
{
int *p = int baru[n];
jika (p == BATAL)
kembali salah;
mergesort(a, 0, n - 1, p);
hapus[] hal;
kembali benar;
}
Efisiensi pengurutan gabungan relatif tinggi. Asumsikan panjang barisan adalah N. Diperlukan langkah-langkah logN untuk membagi barisan menjadi barisan desimal. N), jadi totalnya adalah O(N*logN). Karena pengurutan gabungan beroperasi pada data yang berdekatan setiap saat, beberapa metode pengurutan pengurutan gabungan (pengurutan cepat, pengurutan gabungan, pengurutan bukit, pengurutan heap) di O(N*logN) juga relatif efisien.