Merge sort adalah algoritma pengurutan yang bekerja dengan memecah elemen menjadi bagian-bagian kecil dan menggabungkannya kembali dengan cara membandingkan dan menyusun elemen-elemennya secara terurut. Algoritma ini memiliki kompleksitas waktu sebesar O(n log n) pada kasus rata-rata dan terburuk.

1. Pengurutan
Merge
Algoritma dan
Struktur Data
Georgius Rinaldo
dodo@kuliahkita.com

2. Pendahuluan
Merge sort adalah metode pengurutan yang dilakukan
dengan memecah penampung elemen tepat menjadi 2
sampai tersisa hanya menjadi 1 partisi, kemudian
mengiterasi dengan membandingkan dan
menggabungkan secara berulang.

3. Proses - Memecah
6 5 3 1 8 7 2 4
6 5 3 1 8 7 2 4
6 5 3 1 8 7 2 4
6 5 3 1 8 7 2 4

4. Proses - Membandingkan
Bandingkan satu per satu elemen yang sudah dipecah
6 5 3 1 8 7 2 4

5. Proses - Tukar
Tukar posisi elemen jika posisi tidak benar.
Jika posisi sudah benar, maka lewati dan lanjut ke elemen
berikutnya
5 6 3 1 8 7 2 4

6. Proses - Bandingkan Lagi
Lanjutkan ke dua elemen berikutnya untuk dibandingkan
5 6 3 1 8 7 2 4

7. Proses - Tukar Lagi
Tukar kembali
5 6 1 3 8 7 2 4

8. Proses - Iterasi Selesai
Setelah selesai, gabungkan elemen-elemen yang telah
terurut tadi sehingga membentuk tabel-tabel baru seperti
di gambar berikut
5 6 1 3 7 8 2 4
5 6 1 3 7 8 2 4

9. Proses - Perbandingan Kembali
Bandingkan:
● elemen pertama pada tabel pertama dengan elemen pertama pada tabel kedua dan
sebaliknya secara bergantian
● bandingkan elemen terakhir yang belum dimasukkan ke tabel baru (5) dengan
elemen lainya
5 6 1 3 7 8 2 4
1 3

10. Proses - Perbandingan Kembali
Bandingkan:
● Pada tabel kedua sudah habis
● bandingkan elemen terakhir yang belum dimasukkan ke tabel baru (5) dengan
elemen lainya (6) yang tersisa
5 6 1 3 7 8 2 4
1 3 5 6

11. Hasil Iterasi
Tabel yang baru yang siap dibandingkan dengan proses
yang sama
5 6 1 3 7 8 2 4
1 3 5 6 2 4 7 8

12. Perbandingan Tabel Baru
Lakukan perbandingan seperti sebelumnya
1 3 5 6 2 4 7 8
1 2 3 4 5 6 7 8

13. Pseudocode dengan List
function mergeSort(Input m: list) → list
if length(m) ≤ 1
→ m
var list left, right, result
var integer middle = length(m) / 2
for each x in m up to middle
begin
add x to left
end
for each x in m after middle
begin
add x to right
end
left = mergeSort(left)
right = mergeSort(right)
result = merge(left, right)
→ result
function merge(Input: left list,Input right: list) → list
list result
while (length(left) > 0 or length(right) > 0) do
begin
if (length(left) > 0 and length(right) > 0)
if first(left) ≤ first(right)
append first(left) to result
left = rest(left)
else
append first(right) to result
right = rest(right)
else if length(left) > 0
append first(left) to result
left = rest(left)
else if length(right) > 0
append first(right) to result
right = rest(right)
end
→ result

14. Kode C++
template <class M>
void myMerge( M arr[], int lb, int mid, int ub ) {
int i, j;
int size1 = mid - lb + 1;
int size2 = ub - mid;
M* tmpArray1 = new M[size1];
M* tmpArray2 = new M[size2];
for( i=0; i<size1; i++ ) {
tmpArray1[i] = arr[lb + i];
}
for( j=0; j<size2; j++ ) {
tmpArray2[j] = arr[mid + 1 + j];
}
i = 0; j = i;
… // lanjut ke slide berikutnya

15. Kode C++ - lanjutan
for( int k=lb; k<=ub; k++ ) {
if (i == size1) { // Kalau range array pertama lebih kecil
arr[k] = tmpArray2[j];
j++;
} else if (j == size2) { // Kalau range array kedua lebih kecil
arr[k] = tmpArray1[i];
i++;
} else if ( tmpArray1[i] < tmpArray2[j] ) {
arr[k] = tmpArray1[i];
i++;
} else {
arr[k] = tmpArray2[j];
j++;
}
}
delete[] tmpArray1; //
delete[] tmpArray2; // Bersihkan alokasi arraynya
}

16. Kode C++ - lanjutan 2
void mergeSort( int arr[], int lb, int ub ) {
if (ub - lb > 1) {
int mid = (lb + ub) / 2;
mergeSort(arr, lb, mid);
mergeSort(arr, mid + 1, ub);
myMerge(arr, lb, mid, ub);
} else {
if (arr[ub] < arr[lb]) {
int tmp = arr[ub];
arr[ub] = arr[lb];
arr[lb] = tmp;
}
}
}
// ==================== akhir dari prosedur ====================

17. Kode C++ - lanjutan 3 (main)
#include <iostream>
using namespace std;
int main() {
int numbers[] = { 8, 40, 1, 5, 0, 9, 6, 4, 3, -1, 5 };
mergeSort(numbers, 0, 10);
for (int i=0; i<10; i++) {
cout << numbers[i];
cout << “ | “;
}
}

18. Kompleksitas
Worst Case O(n log n)
Best Case O(n)
Average Case O(n log n)