Nama : Ardhita yuda p.

NPM : 0734010107
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();
}
}
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;
}

Output :