Merge
Sort
Ide algoritma ini hampir mirip
dengan QuickSort, yaitu melakukan partisi.
Kecuali bahwa algoritma ini
melakukan partisi tanpa kriteria.
Jadi, data set (X[l] ... X[r]) di
partisi langsung ke du sub data set dengan jumlah data yang
sama (X[l] ... X[(l+r)/2], dan
X[(l+r)/2+1] ... X[r]).
Lalu secara rekursif melakukan
Merge Sort untuk masing-masing data set.
Karena kedua data set itu bisa
overlapping (tidak seperti pada Quick Sort) maka setelah
kedua sub data set terurut masih
memerlukan proses penggabungan (Merging).
Merging ini memerlukan ruang
tambahan yaitu suatu array yang sama panjangnya dengan
panjang kedua subset untuk
menyimpan hasilnya.
void MergeSort(int l,int r) {
if (l < r) {
MergeSort(l, (l+r)/2);
MergeSort((l+r)/2,r);
Merging();
MergeSort((l+r)/2,r);
Merging();
}
}
Algoritma ini memiliki kompleksitas
O(n log n).
Algoritma Merge Sort
Algoritma Merge adalah algoritma yang dijalankan sebagai
akibat dari terlalu banyaknya daftar yang diurutkan, dengan menghasilkan lebih
banyak daftar yang diurutkan sebagai output. Algoritma merge ini disesuaikan
untuk mesin drive tape. Penggunaannya dalam akses memori acak besar yang
terkait telah menurun, karena banyak aplikasi algoritma merge yang mempunyai
alternatif lebih cepat ketika kamu memiliki akses memori acak yang menjaga
semua data mu. Hal ini disebabkan algoritma ini membutuhkan setidaknya ruang
atau memori dua kali lebih besar karena dilakukan secara rekursif dan memakai
dua tabel.
Algoritma merge sort membagi tabel menjadi dua tabel yang
sama besar. Masing-masing tabel diurutkan secara rekursif, dan kemudian
digabungkan kembali untuk membentuk tabel yang terurut. Implementasi dasar dari
algoritma merge sort memakai tiga buah tabel, dua untuk menyimpan elemen dari tabel
yang telah di bagi dua dan satu untuk menyimpan elemen yang telah terurut.
Namun algoritma ini dapat juga dilakukan langsung pada dua tabel, sehingga
menghemat ruang atau memori yang dibutuhkan.
Algoritma Merge umumnya memiliki satu set pointer p0..n yang
menunjuk suatu posisi di dalam satu set daftar L0..n . Pada awalnya mereka
menunjuk item yang pertama pada setiap daftar. Algoritmanya sebagai berikut:
Selama p0..n masih menunjuk data yang di dalam sebagai
pengganti pada akhirnya:
1. Melakukan sesuatu
dengan data item yang menunjuk daftar mereka masing-masing.
2. Menemukan
pointers points untuk item dengan kunci yang paling rendah; membantu salah satu
pointer untuk item yang berikutnya dalam daftar.
Daftar isi
[sembunyikan]
* 1 Pseudocode
* 2 Implementasi
Algoritma Merge menggunakan MATLAB
* 3 Analisis
* 4 Penggunaan
* 5 Referensi
Suatu implementasi pseudocode sederhana yang tak berulang
dari penggabungan dengan dua daftar yang mungkin tertulis sebagai berikut:
function
merge(a, b)
var list result
var int i, j := 0
while (i < length(a)) and (j <
length(b))
if a[i] < b[j]
add a[i] to result
i := i + 1
else
add b[j] to result
j := j + 1
while i < length(a)
add a[i] to result
i := i + 1
while j < length(b)
add b[j] to result
j := j + 1
return result
[sunting] Implementasi Algoritma Merge menggunakan MATLAB
M-File
function p=merge(a,b)
% MERGE Penggabungan
% MERGE(A,B)
menggabungkan dua list
if nargin<2
error('Kekurangan
argumen input');
end % pengecekan
error
a=a(:); %
meyakinkan bahwa input merupakan vektor baris
b=b(:);
na=length(a); %
menemukan panjang a dan b
nb=length(b);
df=a+b; % hasil
dari daftar
ndf=length(df);
p=[zeros(1,nb-na)
a]+[zeros(1,na-nb) b];
Command window
>> a=[1 2 3]
a =
1
2 3
>> b=[2 3 4]
b =
2
3 4
>> merge(a,b)
ans =
3
5
7
>> p=[3 5 7]
p =
3
5 7
>> for i=1:3
x=a(i)+p(i)
end
x =
4
x =
7
x =
10
>> for j=1:3
y=b(j)+p(j)
end
y =
5
y =
8
y =
11
Pada umumnya algoritma merge berjalan dalam waktu
proposional untuk penjumlahan pada panjangnya daftar; Algoritma merge
beroperasi pada bilangan besar dalam daftar yang akan segera mengalikan
penjumlahan panjangnya daftar pada saat itu untuk keluaran gambar pointers
points yang mana menunjuk pada item yang paling rendah, yang dapat terpengaruhi
dengan suatu heap(tumpukan) yang didasarkan prioritas antrian dalam O(lg n)
waktu, untuk O(m lg n) waktu (dimana n adalah bilangan pada daftar yang
digabungkan, m adalah penjumlahan panjangnya daftar, dan lg adalah log basis
2). Ketika menggabungkan panjang m dua daftar, terdapat suatu perbandingan
lompatan yang lebih rendah 2m-1 yang ada dalam kasus terburuk.
Keluaran data item Merge klasik (satu yang digunakan dalam
merge sort) dengan kunci yang paling rendah pada langkah masing-masing,
memberikan beberapa daftar yang diurutkan, hasil daftar yang diurutkan berisi
semua unsur-unsur di dalam daftar input manapun, dan hal itu dilakukan agar
waktunya proporsioal untuk input penjumlahan panjangnya daftar.
Penggabungan dapat
juga digunakan untuk berbagai hal:
* Diberikan satu set saldo-saldo rekening
yang beredar dan satu set transaksi, kedua-duanya disortir oleh nomor rekening,
menghasilkan satu saldo-saldo rekening baru setelah transaksi diterapkan; ini
selalu diperlukan untuk mempercepat ”transaksi baru” penunjuk ketika keduanya
mempunyai kunci yang sama, dan menambahkan semua angka-angka pada tape yang
manapun dengan nomor rekening yang sama untuk menghasilkan saldo yang baru.
* Menghasilkan
suatu daftar catatan yang disortir dengan menyajikan kunci disemua daftar ini
yang memerlukan outputting kapan saja suatu catatan yang semua kunci p0..n
adalah sama.
* Dengan cara yang
sama untuk menemukan bilangan besar pada satu tape yang lebih kecil
dibandingkan masing-masing nomor pada satu tape yang lainnya (contoh untuk
mengeluarkan gambar pengelompokan pajak masing-masing orang di dalamnya).
* Dengan cara yang
sama untuk menghitung perbedaan set semua arsip dalam satu daftar dengan arsip
yang tidak sesuaian dengan yang lainnya.
* Operasi
penyisipan dalam mesin pencarian untuk menghasilkan suatu indeks balikkan.
* Menggabungkan
permainan-permainan adalah suatu peranan pusat dalam fungsi pemrograman teknik
Dijkstra untuk menghasilkan bilangan-bilangan tetap.
Source Code Merge Sort
#include
<stdio.h>
#include
<stdlib.h>
#include
<string.h>
void
printv(char* in, int *v, int n) {
printf("%s", in);
int i = 0;
for (; i < n; ++i)
printf("%d ",
v[i]);
printf("\n");
}
void
merge(int *v, int p, int q, int r) {
int i = p;
int j = q + 1;
int *tmp = (int*)malloc((r - p + 1)
* sizeof(int));
int k = 0;
while ((i <= q) && (j
<= r)) {
if (v[i] < v[j])
tmp[k++] =
v[i++];
else
tmp[k++] =
v[j++];
}
while (i <= q)
tmp[k++] = v[i++];
while (j <= r)
tmp[k++] = v[j++];
memcpy(v + p, tmp, (r - p + 1) *
sizeof(int));
free(tmp);
}
void
mergeS(int *v, int p, int r) {
if (p < r) {
int q = (p + r) / 2;
mergeS(v, p, q);
mergeS(v, q + 1, r);
merge(v, p, q, r);
}
}
int
main(int argc, char *argv[]) {
int n = 10;
int v[] = {9, 8, 7, 6, 5, 5, 4, 3,
2, 1};
printv("V: ", v, n);
mergeS(v, 0, n - 1);
printv("V: ", v, n);
return 0;
}