METODE DIVIDE DAN CONQUER

Makalah ini diajukan untuk memenuhi salah satu tugas mata kuliah Analisis dan Desain
Algoritma

Dosen : Erna Dwi Astuti, M.Kom

Dibuat Oleh :

Imam Jauhari 2016157014

Sabar Setiadi 20161570

Eko Prasetyo 20161570

FAKULTAS TEKNIK INFORMATIKA

UNIVERSITAS SAINS ALQURAN WONOSOBO

2018
 KATA PENGANTAR

Puji syukur penulis penjatkan kehadirat Alloh SWT, karena atas rahmat-Nya maka
penulis dapat menyelesaikan penyusunan makalah ini dengan baik dan lancar.

Makalah ini berjudul “ Metode Divide dan Conquer” merupakan hasil dari kumpulan
beberapa sumber dan terjemahan dari sumber-sumber yang menggunakan Bahasa Inggris.

Dalam penyusunan makalah ini, tidak sedikit hambatan yang penulis hadapi. Namun
penulis menyadari bahwa kelancaran dalam penyusunan makalah ini tidak lain berkat bantuan,
bimbingan dan dorongan semua pihak, sehingga kendala-kendala yang penulis hadapi teratasi.
Oleh karena itu penulis mengucapkan terima kasih kepada :

1. Erna Dwi Astuti, M.Kom, sebagai dosen pembimbing mata kuliah Analisis dan Desain
Algoritma.
2. Orang Tua yang telah memberikan dukungan dan semangat sehingga makalah ini dapat
terselesaikan dengan lancar.
3. Semua pihak yang telah mendukung pembuatan makalah ini.

“Tak Ada Gading Yang Tak Retak” maka dari itu penyusun menerima kritik dan saran
yang membangun demi perbaikan makalah ini. Semoga makalah ini dapat menjadi makalah
yang bermanfaat.
 BAB I
PENDAHULUAN

A. Latar Belakang
Dalam ilmu komputer, pemecahan masalah dengan cara “membagi dan
menaklukan” suatu algoritma merupakan paradigma penting berdasarkan multi-cabang
rekursi. Teknik ini merupakan teknik dasar dalam menyelesaikan masalah-masalah,
seperti sortasi (misalnya quicksort, merge sort), mengalikan jumlah besar, analisis
sintaksis dan menghitung Fourier Diskrit mengubah (FFTs).
Disisi lain, kemampuan untuk memahami dan merancang algoritma adalah
keterampilan yang membutuhkan waktu untuk menguasai. Karena setiap permasalahan
algoritma merupakan permasalahan yang rumit dan harus diselesaikan dengan cara
menaklukan permasalahan itu dan membagi menjadi permasalah yang lebih kecil.
Maka dari itu penulis membuat makalah ini yaitu tentang pengurangan permasalahan-
permasalahan dalam algoritma yag diselesaikan dengan metode divide dan conquer.

B. Rumusan Masalah
Berdasarkan latar belakang diatas, maka rumusan masalahnya sebagai berikut :
1. Apakah metode divide dan conquer itu?
2. Bagaimana penerapan algoritma dengan divide dan conquer?
3. Bagaimanakah keuntungan dan kelemahan menggunakan metode divide dan
conquer?
4. Apakah menggunakan metode divide dan conquer merupakan pemecahan
masalah yang efisien?

C. Tujuan
1. Mengetahui pengertian dari metode divide dan conquer.
2. Mengetahui penerapan algoritma dengan metode divide dan conquer.
3. Mengetahui keuntungan dan kelemahan pemecahan masalah dengan
menggunakan metode divide dan conquer.
4. Mengetahui efisiensi pemecahan masalah dengan menggunakan metode
divide dan conquer.

D. Manfaat
Penulis berharap dengan adanya makalah yang berjudul Metode Divide dan Conquer
ini menjadi makalah yang bermanfaat khususnya dalam dunia pendidikan. Terlebih lagi
bisa menjadi suatu rujukan dan pemahaman yang lebih mengenai permasalahan yang
dibahas dalam makalah ini. Sehingga makalah ini menjadi makalah yang bermanfaat.
 BAB II
KAJIAN PUSTAKA
ALGORITMA DIVIDE AND CONQUER

Algoritma Divide and Conquer merupakan algoritma yang sangat populer di dunia Ilmu
Komputer. Divide and Conquer merupakan algoritma yang berprinsip memecah-mecah
permasalahan yang terlalu besar menjadi beberapa bagian kecil sehingga lebih mudah untuk
diselesaikan. Langkah-langkah umumalgoritma Divide and Conquer :

 Divide : Membagi masalah menjadi beberapa upa-masalah yang memiliki kemiripan

dengan masalah semula namun berukuran lebih kecil ( idealnya berukuran hampir sama
)
 Conquer : Memecahkan ( menyelesaikan ) masing-masing upa-masalah ( secara
rekursif ).
 Combine : Menggabungkan solusi masing-masing upa-masalah sehingga membentuk
solusi masalah semula.

Skema Algoritma Divide and Conquer

 Objek masalah yang di bagi adalah masukan (input) atau instances yang berukuran n:
tabel (larik), matriks, dan sebagainya, bergantung pada masalahnya. Tiap-tiap upa-masalah
mempunyai karakteristik yang sama (the same type) dengan karakteristik masalah asal,
sehingga metode Divide and Conquer lebih natural diungkapkan dalam skema rekursif. Sesuai
dengan karakteristik pembagian dan pemecahan masalah tersebut, maka algoritma ini dapat
berjalan baik pada persoalan yang bertipe rekursif ( perulangan dengan memanggil dirinya
sendiri ). Dengan demikian, algoritma ini dapat diimplementasikan dengan cara iteratif (
perulangan biasa ), karena pada prinsipnya iteratif hampir sama dengan rekursif.

Salah satu penggunaan algoritma ini yang paling populer adalah dalam hal pengolahan
data yang bertipe array ( elemen larik ). Mengapa? Karena pengolahan array pada umumnya
selalu menggunakan prinsip rekursif atau iteratif. Penggunaan secara spesifik adalah untuk
mencari nilai minimal dan maksimal serta untuk mengurutkan elemen array. Dalam hal
pengurutan ini ada empat macam algoritma pengurutan yang berdasar pada algoritma Divide
and Conquer, yaitu merge sort, insert sort, quick sort, dan selection sort. Merge sort dan Quick
sort mempunyai kompleksitas algoritma O(n log n). Hal ini lebih baik jika dibandingkan
dengan pengurutan biasa dengan menggunakan algoritma brute force.

Sebelum masuk ke pokok pemrograman dengan “Divide and Conquer

strategy/algorithm”, ada 4 hal penting yang harus dipahami dalam strategi ini : branching
factor, balance, data dependence of divide function dan sequentiality.

1. Branching Factor
Branching factor dalam algoritma divide and conquer adalah jumlah dari subproblem
yang akan dibagi dari sebuah problem awal. Ini adalah langkah nyata dari algoritma
divide and conquer, didalam proses pembagian yang sebenarnya, jumlah dari branching
factor harus 2 atau lebih, karena jika tidak problem tidak bisa dibagi. Banyak jenis
algoritma ini termasuk pula algoritma komputasi geometric yang memiliki branching
factor berjumlah 2.
2. Balance
Sebuah algoritma divide and conquer dikatakan balance jika problem awal dibagi
menjadi sub-sub problem dengan ukuran yang sama. Yang artinya jumlah dari
keseluruhan ukuran subproblem sama dengan ukuran problem awal (initial problem).
Algoritma Mergesort dan binary tree, dan sama halnya dengan algoritma reduksi
&prefix sum adalah beberapa contoh algoritma divide and conquer yang seimbang
(balance).
 3. Data Dependence of Divide Function
Algoritma divide and conquer memiliki sebuah fungsi pembagian terhadap data yang
memiliki ketergantungan, artinya jika ukuran relatif dari sebuah Pseudocode untuk
model algoritma n-way divide and conquer subproblem tergantung pada proses input
datanya. Ini adalah salah satu ciri dari algoritma yang tidak seimbang, salah satu
contohnya adalah algoritma quicksort yang akan membagi subproblem dengan fungsi
data-dependent divide.
4. Control Parallelism or Sequentiality
Algoritma divide and conquer dikatakan berurutan (sequential) jika subproblem
dieksekusi sesuai dengan perintah program. Paralelisasi dari algoritma divide and
conquer yang terurut pertama kali didefinisikan oleh Mou’s Divacon[Mou90],yang
terjadi ketika hasil dari salah satu sub-eksekusi diperlukan oleh subeksekusi yang lain.
Dalam kasus ini hasil dari subtree pertama diberikan(passing) kepada proses komputasi
subtree kedua, supaya hasil akhir tersebutbisa digunakan sebagai nilai awalnya, tetapi
sekarang ini contoh diatas tidakdapat dijadikan ilustrasi lagi karena teknologi komputer
paralel yang semakincanggih dan kompleks.

Skema Umum Algoritma Divide and Conquer

 Penerapan algoritma divide dan conquer menurut beberpa sumber bahwa algoritma ini
dapat dipakai dalam berbagai hal diantaranya :

1. Sorting:
a. Quicksort
Quicksort ditemukan oleh C.A.R Hoare. Seperti pada merge Sort, algoritma ini juga
berdasar pada pola divide dan conquer. Berbeda dengan Merge Sort, algoritma ini
hanya mengikuti langkah-langkah berikut :
 Divide yaitu memilah masalah menjadi sub-sub masalah
 Conquer yaitu mengurutkan elemen pada sub rangkaian secara rekursif.
 Pada algoritma quicksort, langkah kombinasi tidak dilakukan karena telah
terjadi pengurutan elemen-elemen pada sub array.
2. Computational Geometry yang terdiri dari :
a. Closest Pairs
Closest Pairs adalah memcari pasangan titik yang jaraknya paling dekat yaitu
dengan cara jika n = 2, maka jarak kedua titik dihitung langsung dengan rumus
Euclidean. Setelah itu bagi menjadi dua bagian yaitu Pleft dan Pright, setiap bagian
mempuny ai jumlah titik yang sama. Setelah kedua jarak tersebut mempunyai jarak
yang sama, maka secara rekursif terapkan algoritma D dan C pada masing-masing
bagian yang akan menghasilkan tiga kemungkinan jarak terdekat dari titk tersebut.
Dan akhirnya jarak titik yang paling dekat terdapat pada Pleft.
b. Convex Hull
Pada penyelesaian masalah pencarian convex hull dengan menggunakan algoritma
divide dan conquer, hal ini dapat dipandang sebagai generalisasi dari algoritma
pengurutan merge sort. Permasalahan convex hull adalah sebuah permasalahan
yang memiliki aplikasi terapan yang cukup banyak, seperti permasalahan terhadap
grafika komputer, otomasi desain, pengenalan pola (pattern recognition), dan
penelitian operasi. Algoritma divide dan conquer merupakan salah satu solusi
dalam penyelesaian masalah convex hull. Algoritma ini ternyata memiliki
kompleksitas waktu yang cukup kecil dan efektif dalam menyelesaikan
permasalahan ini (jika dibandingkan algoritma lain). Selain itu juga, algoritma ini
dapat di generalisasi untuk permasalahan convex hull yang berdimensi lebih dari
tiga.
c. Delaunay Triangulation
 3. Graph Theory yang terdiri dari :
a. Travelling Salesman Problem (TSP)
b. Graph Separator
4. Numerical yang terdiri dari :
a. Matrix Multiplication
b. Fast Fourier transform (FFT)
5. Not Data Parallel yang terdiri dari :
a. Naive Merge Sort

Keuntungan dan Kelemahan Metode Divide dan Conquer

1. Berikut ini adalah beberapa keuntungan dengan menggunakan algoritma divide dan
conquer.
a. Dapat memecahkan permasalahan yang sulit (kompleks)
Algoritma divide and conquer merupakan alat yang sangat berguna untuk
memecahkan masalah yang kompleks, contohnya dalam permainan Menara Hanoi
(Tower of Hanoi). Penyelesaian yang harus dilakukan adalah membagi menjadi
beberapa bagian masalah dan mencari solusi yang tepat lalu dilakukan berulang kali
(rekursif).
b. Efisien
Dalam masalah pengurutan, algoritma divide and conquer dapat menjadi solusi
yang baik untuk mengatasi efisiensi. Sebagai contoh, metoda quicksort dan
mergesort memiliki dasar algoritma divide and conquer dan dikenal sebagaimetode
pengurutan yang paling efesien. Efisiensi algoritma divide and conquer bernotasi
O(n log n).
c. Paralel
Penggunaan algoritma divide and conquer sesuai untuk eksekusi pada mesin multi
prosessor ,terutama pembagian sistem memori dimana sub-masalah dapat
dijalankan pada prosessor yang berbeda.
d. Akses Memori
Permasalahan yang diselesaikan dengan algoritma divide and conquer juga dapat
berpengaruh dalam pengaksesan memori, dikarenakan masalah dibagi menjadi
beberapa bagian dan setiap bagian diselesaikan dengan solusi yang sama maka
dalam pengaksesan memori setiap sub-masalah diselesaikan cukup dengan
mengakses cache memory yang tidak terlalu lambat.
2. Berikut ini adalah kelemahan jika menggunakan algoritma divide dan conquer
a. Sering menggunakan rekursi yang menyebabkan overhead.
b. Lebih rumit untuk masalah yang sederhana
Untuk pemecahan masalah yang relatif sederhana, algoritma sekuensial terbukti
lebih mudah dibuat daripada algoritma divide and conquer. Hal ini disebabkan
karena algoritma sekuensial tidak perlu melalui ketiga langkah yang dilakukan oleh
divide and conquer. Salah satu contohnya ialah, untuk menambah n-banyak
bilangan, perulangan sederhana akan lebih mudah dibuat daripada harus memecah
n-bilangan tersebut.
 BAB III
ANALISA DAN PEMBAHASAN

Implementasi Divide and Conquer pada Merge Sort

Algoritma merge sort dirancang untuk memenuhi kebutuhan pengurutan jika data yang
diurutkan berjumlah banyak, dan tidak memungkinkan untuk ditampung dalam memori
komputer. Cara kerja atau konsep dari algoritma merge sort adalah menggunakan metode
rekursif dan teknik divide and conquer.
Misalnya kita memiliki array yang memiliki 5 buah elemen. Data tersebut nantinya akan
diurutkan sesuai ascending (menaik). Variabel kiri pada program menandakan indeks elemen
awal, sehingga kiri=0, dan kanan menandakan indeks elemen terakhir pada array, sehingga
kanan=panjang elemen – 1 = 5-1 = 4. Sehingga array memiliki range indeks antara 0 sampai
dengan 4. Misalkan data yang dimasukkan adalah sebagai berikut

Indeks ke- 0 1 2 3 4

Data 9 6 11 4 7

Baris ke-5 akan memeriksa apakah nilai variabel kiri < kanan. Variabel kiri bernilai 0 dan
variabel kanan bernilai 4, sehingga pernyataan 0 < 4 bernilai benar. Karena benar maka akan
dilakukan perintah pada baris ke-7

Dibentuk variabel baru yaitu variabel median. Nilai median didapat dari penghitungan (kanan
+ kiri)/2. Nilai kanan adalah 4 dan nilai kiri adalah 0, sehingga median = (4+0)/2 = 2.

Perintah pada baris 8 dan 9 kemudian akan dilakukan. Perintah mergeSort(array, kiri, median)
dan mergeSort(array, median + 1, kanan) akan melakukan rekursi terhadap dirinya sendiri
hingga pernyataan kiri<kanan bernilai salah, sehingga akan dilakukan pemanggilan fungsi
pada baris 8, dengan nilai kiri=0, median=2, dan kanan=4 yaitu mergeSort(array, 0, 2) dan
pada baris 9 yaitu mergeSort(array, 3, 4). Setelah menjalankan mergeSort(array,0,2) dan
mergeSort(array,3,4) secara menyeluruh, maka program akan langsung menuju baris ke-10.

1. mergeSort(array, 0, 2)
Program kembali pada baris 4 dan membandingkan apakah kiri < kanan. Nilai kiri
menjadi 0 dan nilai kanan menjadi 2. Karena 0<2, maka perintah median akan
dilakukan, sehingga median = (kanan+kiri)/2 = (2+0)/2 = 1.
Perintah pada baris 8 dan 9 kemudian akan dilakukan. Perintah mergeSort(array, kiri,
median) dan mergeSort(array, median + 1, kanan) akan melakukan rekursi terhadap
dirinya sendiri hingga pernyataan kiri<kanan bernilai salah, sehingga akan dilakukan
pemanggilan fungsi pada baris 8, dengan nilai kiri=0, median=1, dan kanan=2 yaitu
mergeSort(array, 0, 1) dan pada baris 9 yaitu mergeSort(array, 2, 2).

1.1. mergeSort(array,0,1)
Program kembali pada baris 4 dan membandingkan apakah kiri < kanan. Nilai
kiri menjadi 0 dan nilai kanan menjadi 1. Karena 0<1, maka perintah median
akan dilakukan, sehingga median = (kanan+kiri)/2 = (1+0)/2 = 0.
Perintah pada baris 8 dan 9 kemudian akan dilakukan. Perintah
mergeSort(array, kiri, median) dan mergeSort(array, median + 1, kanan) akan
melakukan rekursi terhadap dirinya sendiri hingga pernyataan kiri<kanan
bernilai salah, sehingga akan dilakukan pemanggilan fungsi pada baris 8,
dengan nilai kiri=0, median=0, dan kanan=1 yaitu mergeSort(array, 0, 0) dan
pada baris 9 yaitu mergeSort(array, 1, 1).
1.1.1. mergeSort(array, 0, 0)
Program kembali pada baris 4 dan membandingkan apakah kiri <
kanan. Nilai kiri menjadi 0 dan nilai kanan menjadi 0. Karena 0<0
bernilai salah, maka program berhenti melakukan rekursi.
1.1.2. mergeSort(array,1,1)
Program kembali pada baris 4 dan membandingkan apakah kiri <
kanan. Nilai kiri menjadi 1 dan nilai kanan menjadi 1. Karena 1<1
bernilai salah, maka program berhenti melakukan rekursi.
Karena program rekursif sudah berhenti, maka program akan melanjutkan pada
baris selanjutnya dengan nilai kiri=0, median=0, dan kanan=1. Perintah baris
ke-10 dan 11 kemudian akan dieksekusi

Variabel akhir dan awal dibentuk. Nilai variabel akhir adalah sama dengan nilai
median yaitu 0, sedangkan nilai variabel awal yaitu sama dengan median+1
yaitu 1. Program melanjutkan ke baris selanjutnya

Program akan melakukan fungsi perulangan dengan while. Perulangannya

adalah sebagai berikut
 Selama nilai kiri ≤ akhir dan nilai awal ≤ kanan, dan apabila array pada
indeks kiri (array[kiri]) lebih kecil dari array indeks awal (array[awal])
maka nilai kiri akan melakukan increment sebesar 1. Artinya sub-
masalah sudah terurut dengan benar.
  Selama nilai kiri ≤ akhir dan nilai awal ≤ kanan, dan apabila array pada
indeks kiri (array[kiri]) lebih besar dari array indeks awal (array[awal])
maka akan dibentukvariabel bantu yaitu temp. Variabel temp akan
membantu program untuk melakukan pertukaran data antara array[kiri]
dengan array[awal].
Berdasarkan contoh data, maka

Indeks ke- 0 1 2 3 4

Data 9 6 11 4 7

array[kiri] array[awal] & array[kanan]

Data menunjukkan bahwa nilai kiri ≤ akhir (0≤1) dan nilai awal ≤ kanan (1≤1)
maka program akan membandingkan kembali, apakah array[kiri] < array[awal]
atau tidak. Karena 9 > 6, maka otomatis program akan menjalankan perintah di
bawah else.
Variabel temp dibentuk dan nilainya sama dengan array[awal] sehingga temp
akan menyimpan nilai 6 untuk sementara. Kemudian dibentuk variabel k yang
akan langsung masuk ke perulangan for. Untuk nilai k= awal-1 hingga nilai k ≥
kiri, maka array[k+1] akan menenmpati array[k], dan nilai k akan berkurang
sebesar 1 hingga pernyataan tersebut bernilai false. Nilai awal adalah 1 dan nilai
kiri adalah 0, sehingga nilai k = awal-1 = 0 dan batas akhirnya adalah k ≥ 0 (k ≥
kiri).
Untuk k = 0, maka array[0+1] akan menempati array[0]. Dapat dilihat bahwa
array[1] adalah 6 dan array[0] adalah 9, sehingga array[1] kini bernilai sama
dengan array[0] yaitu 9. Setelah array[1] kini bernilai 9, perulangan for akan
kembali melakukan pengecekan. Ternyata perulangan for kini sudah bernilai
false, sebab batas awal adalah k=0 dan batas akhir adalah k≥0, sehingga hanya
dilakukan 1x perulangan saja. Program melanjutkan ke baris 22
Baris ke-22 kemudian menyatakan array[kiri] = temp, sehingga array[0] akan
sama dengan nilai yang disimpan pada variabel temp yaitu 6. Sehingga
urutannya menjadi sebagai berikut
Indeks ke- 0 1

Data 6 9
 Data sudah terurut sehingga perintah baris ke-23 hingga 25 akan dieksekusi
dimana variabel kiri, akhir, dan awal akan melakukan increment sebesar 1. Nilai
kiri menjadi 1, akhir menjadi 2, dan awal menjadi 2. Program kembali ke
perulangan while. Pengecekan kembali dilakukan apakah kiri ≤ akhir dan awal
≤ kanan. Ternyata nilai 1 ≤ 2 (kiri ≤ akhir) dan nilai 2 ≤ 1 (awal ≤ kanan) bernilai
salah, sehingga perulangan while berhenti.

1.2. mergeSort(array,2,2)
Program kembali pada baris 4 dan membandingkan apakah kiri < kanan. Nilai
kiri menjadi 2 dan nilai kanan menjadi 2. Karena 2<2 bernilai salah, maka
program berhenti melakukan rekursi.

Program sudah berhenti melakukan rekursi. Artinya kini giliran mergeSort(array, 0, 2)

yang akan dijalankan dengan nilai kiri=0, median=1, dan kanan=2. Perintah baris ke-
10 dan 11 kemudian akan dieksekusi

Variabel akhir dan awal dibentuk. Nilai variabel akhir adalah sama dengan nilai median
yaitu 1, sedangkan nilai variabel awal yaitu sama dengan median+1 yaitu 2. Program
melanjutkan ke baris selanjutnya

Program akan melakukan fungsi perulangan dengan while. Perulangannya adalah

sebagai berikut
 Selama nilai kiri ≤ akhir dan nilai awal ≤ kanan, dan apabila array pada indeks
kiri (array[kiri]) lebih kecil dari array indeks awal (array[awal]) maka nilai
kiri akan melakukan increment sebesar 1. Artinya sub-masalah sudah terurut
dengan benar.
 Selama nilai kiri ≤ akhir dan nilai awal ≤ kanan, dan apabila array pada indeks
kiri (array[kiri]) lebih besar dari array indeks awal (array[awal]) maka akan
 dibentukvariabel bantu yaitu temp. Variabel temp akan membantu program
untuk melakukan pertukaran data antara array[kiri] dengan array[awal].
Berdasarkan contoh data, maka

Indeks ke- 0 1 2 3 4

Data 6 9 11 4 7

array[kiri] array[awal] & array[kanan]

Data menunjukkan bahwa nilai kiri ≤ akhir (1≤1) dan nilai awal ≤ kanan (2≤2) maka
program akan membandingkan kembali, apakah array[kiri] < array[awal] atau tidak.
Karena 9 < 11, maka otomatis program akan menjalankan perintah pada baris ke-15.
Variabel kiri akan melakukan increment sebesar 1, sehingga nilai variabel kiri kini
menjadi 2. Perintah while kembali dilakukan dan melakukan pengecekan. Data kini
menunjukkan nilai kiri≤ akhir (2≤1) dan nilai awal ≤ kanan (2≤2). Pernyataan tersebut
bernilai false, sehingga program berhenti. Hasil program sementara adalah sebagai
berikut
Indeks ke- 0 1 2

Data 6 9 11

2. mergeSort(array,3,4)
Program kembali pada baris 4 dan membandingkan apakah kiri < kanan. Nilai kiri
menjadi 3 dan nilai kanan menjadi 4. Karena 3<4, maka perintah median akan
dilakukan, sehingga median = (kanan+kiri)/2 = (4+3)/2 = 3.
Perintah pada baris 8 dan 9 kemudian akan dilakukan. Perintah mergeSort(array, kiri,
median) dan mergeSort(array, median + 1, kanan) akan melakukan rekursi terhadap
dirinya sendiri hingga pernyataan kiri<kanan bernilai salah, sehingga akan dilakukan
pemanggilan fungsi pada baris 8, dengan nilai kiri=3, median=3, dan kanan=4 yaitu
mergeSort(array, 3, 3) dan pada baris 9 yaitu mergeSort(array, 4, 4).
2.1. mergeSort(array,3,3)
Program kembali pada baris 4 dan membandingkan apakah kiri < kanan. Nilai
kiri menjadi 3 dan nilai kanan menjadi 3. Karena 3<3 bernilai salah, maka
program berhenti melakukan rekursi.
2.2. mergeSort(array,4,4)
 Program kembali pada baris 4 dan membandingkan apakah kiri < kanan. Nilai
kiri menjadi 4 dan nilai kanan menjadi 4. Karena 4<4 bernilai salah, maka
program berhenti melakukan rekursi.

Program sudah berhenti melakukan rekursi. Artinya kini giliran mergeSort(array, 3, 4)

yang akan dijalankan dengan nilai kiri=3, median=3, dan kanan=4. Perintah baris ke-
10 dan 11 kemudian akan dieksekusi

Variabel akhir dan awal dibentuk. Nilai variabel akhir adalah sama dengan nilai median
yaitu 3, sedangkan nilai variabel awal yaitu sama dengan median+1 yaitu 4. Program
melanjutkan ke baris selanjutnya

Program akan melakukan fungsi perulangan dengan while. Perulangannya adalah

sebagai berikut
 Selama nilai kiri ≤ akhir dan nilai awal ≤ kanan, dan apabila array pada indeks
kiri (array[kiri]) lebih kecil dari array indeks awal (array[awal]) maka nilai
kiri akan melakukan increment sebesar 1. Artinya sub-masalah sudah terurut
dengan benar.
 Selama nilai kiri ≤ akhir dan nilai awal ≤ kanan, dan apabila array pada indeks
kiri (array[kiri]) lebih besar dari array indeks awal (array[awal]) maka akan
dibentukvariabel bantu yaitu temp. Variabel temp akan membantu program
untuk melakukan pertukaran data antara array[kiri] dengan array[awal].
Berdasarkan contoh data, maka

Indeks ke- 0 1 2 3 4

Data 6 9 11 4 7
 array[kiri] array[awal] & array[kanan]
Data menunjukkan bahwa nilai kiri ≤ akhir (3≤3) dan nilai awal ≤ kanan (4≤4) maka
program akan membandingkan kembali, apakah array[kiri] < array[awal] atau tidak.
Karena 4 < 7, maka otomatis program akan menjalankan perintah pada baris ke-15.
Variabel kiri akan melakukan increment sebesar 1, sehingga nilai variabel kiri kini
menjadi 5. Perintah while kembali dilakukan dan melakukan pengecekan. Data kini
menunjukkan nilai kiri≤ akhir (5≤4) dan nilai awal ≤ kanan (4≤4). Pernyataan tersebut
bernilai false, sehingga program berhenti. Hasil program sementara adalah sebagai
berikut
Indeks ke- 3 4

Data 4 7

Sampai disini program masih belum selesai dieksekusi. Untuk sementara urutan data adalah
sebagai berikut

Indeks ke- 0 1 2 3 4

Data 6 9 11 4 7

Program melanjutkan esekusinya dengan nilai variabel kiri, median, dan kanan mula-mula.
Variabel kiri memiliki nilai mula-mula 0, variabel kanan memiliki nilai mula-mula 4 dan
variabel median memiliki nilai mula-mula 2. Program melanjutkan eksekusi ke baris 10.

Variabel akhir dan awal dibentuk. Nilai variabel akhir adalah sama dengan nilai median yaitu
2, sedangkan nilai variabel awal yaitu sama dengan median+1 yaitu 3. Program melanjutkan
ke baris selanjutnya
Program akan melakukan fungsi perulangan dengan while. Perulangannya adalah sebagai
berikut

 Selama nilai kiri ≤ akhir dan nilai awal ≤ kanan, dan apabila array pada indeks kiri
(array[kiri]) lebih kecil dari array indeks awal (array[awal]) maka nilai kiri akan
melakukan increment sebesar 1. Artinya sub-masalah sudah terurut dengan benar.
 Selama nilai kiri ≤ akhir dan nilai awal ≤ kanan, dan apabila array pada indeks kiri
(array[kiri]) lebih besar dari array indeks awal (array[awal]) maka akan
dibentukvariabel bantu yaitu temp. Variabel temp akan membantu program untuk
melakukan pertukaran data antara array[kiri] dengan array[awal].

Berdasarkan contoh data, maka

Indeks ke- 0 1 2 3 4

Data 6 9 11 4 7

array[kiri] array[awal] array[kanan]

Data menunjukkan bahwa nilai kiri ≤ akhir (0≤2) dan nilai awal ≤ kanan (3≤4) maka program
akan membandingkan kembali, apakah array[kiri] < array[awal] atau tidak. Karena 6 > 4, maka
otomatis program akan menjalankan perintah di bawah else.

Variabel temp dibentuk dan nilainya sama dengan array[awal] sehingga temp akan menyimpan
nilai 4 untuk sementara. Kemudian dibentuk variabel k yang akan langsung masuk ke
perulangan for. Untuk nilai k= awal-1 hingga nilai k ≥ kiri, maka array[k+1] akan menenmpati
array[k], dan nilai k akan berkurang sebesar 1 hingga pernyataan tersebut bernilai false. Nilai
awal adalah 3 dan nilai kiri adalah 0, sehingga nilai k = awal-1 = 2 dan batas akhirnya adalah
k ≥ 0 (k ≥ kiri).

Untuk k = 2, maka array[2+1] akan menempati array[2]. Dapat dilihat bahwa array[3] adalah
4 dan array[2] adalah 11, sehingga array[3] kini bernilai sama dengan array[2] yaitu 11. Setelah
array[3] kini bernilai 11, perulangan for akan kembali melakukan pengecekan.

Indeks ke- 0 1 2 3 4

Data 6 9 11 11 7
Untuk k = 1, maka array[1+1] akan menempati array[1]. Dapat dilihat bahwa array[2] adalah
11 dan array[1] adalah 9, sehingga array[2] kini bernilai sama dengan array[1] yaitu 9. Setelah
array[2] kini bernilai 9, perulangan for akan kembali melakukan pengecekan.

Indeks ke- 0 1 2 3 4

Data 6 9 9 11 7

Untuk k = 0, maka array[0+1] akan menempati array[0]. Dapat dilihat bahwa array[1] adalah
9 dan array[0] adalah 6, sehingga array[1] kini bernilai sama dengan array[0] yaitu 6. Setelah
array[1] kini bernilai 6, perulangan for akan kembali melakukan pengecekan.

Indeks ke- 0 1 2 3 4

Data 6 6 9 11 7

Ternyata perulangan for kini sudah bernilai false, sebab batas awal adalah k=2 dan batas akhir
adalah k≥0 dan nilai k sudah mencapai k=0. Program melanjutkan ke baris 22

Baris ke-22 kemudian menyatakan array[kiri] = temp, sehingga array[0] akan sama dengan
nilai yang disimpan pada variabel temp yaitu 4. Sehingga urutannya menjadi sebagai berikut

Indeks ke- 0 1 2 3 4

Data 4 6 9 11 7

Perintah baris ke-23 hingga 25 akan dieksekusi dimana variabel kiri, akhir, dan awal akan
melakukan increment sebesar 1. Nilai kiri menjadi 1, akhir menjadi 3, dan awal menjadi 4.
Program kembali ke perulangan while. Pengecekan kembali dilakukan apakah kiri ≤ akhir dan
awal ≤ kanan. Ternyata nilai 1 ≤ 3 (kiri ≤ akhir) dan nilai 4 ≤ 4 (awal ≤ kanan) bernilai benar,
sehingga perulangan while kembali dilakukan.

Program akan melakukan fungsi perulangan dengan while. Perulangannya adalah sebagai
berikut

 Selama nilai kiri ≤ akhir dan nilai awal ≤ kanan, dan apabila array pada indeks kiri
(array[kiri]) lebih kecil dari array indeks awal (array[awal]) maka nilai kiri akan
melakukan increment sebesar 1. Artinya sub-masalah sudah terurut dengan benar.
  Selama nilai kiri ≤ akhir dan nilai awal ≤ kanan, dan apabila array pada indeks kiri
(array[kiri]) lebih besar dari array indeks awal (array[awal]) maka akan
dibentukvariabel bantu yaitu temp. Variabel temp akan membantu program untuk
melakukan pertukaran data antara array[kiri] dengan array[awal].

Berdasarkan contoh data, maka

Indeks ke- 0 1 2 3 4

Data 4 6 9 11 7

array[kiri] array[awal] & array[kanan]

Data menunjukkan bahwa nilai kiri ≤ akhir (1≤3) dan nilai awal ≤ kanan (4≤4) maka program
akan membandingkan kembali, apakah array[kiri] < array[awal] atau tidak. Karena 6 < 7, maka
otomatis program akan menjalankan perintah pada baris ke-15. Variabel kiri akan melakukan
increment sebesar 1, sehingga nilai variabel kiri kini menjadi 2. Perintah while kembali
dilakukan dan melakukan pengecekan. Data kini menunjukkan nilai kiri≤ akhir (2≤3) dan nilai
awal ≤ kanan (4≤4). Pernyataan bernilai true dan program akan membandingkan kembali,
apakah array[kiri] < array[awal] atau tidak. Karena array[kiri]=array[2]=9 lebih besar dari
array[awal]=array[4]=7, maka program langsung menjalankan perintah di bawah else.

Berdasarkan contoh data, maka

Indeks ke- 0 1 2 3 4

Data 4 6 9 11 7

array[kiri] array[awal] & array[kanan]

Variabel temp dibentuk dan nilainya sama dengan array[awal] sehingga temp akan menyimpan
nilai 7 untuk sementara. Kemudian dibentuk variabel k yang akan langsung masuk ke
perulangan for. Untuk nilai k= awal-1 hingga nilai k ≥ kiri, maka array[k+1] akan menenmpati
array[k], dan nilai k akan berkurang sebesar 1 hingga pernyataan tersebut bernilai false. Nilai
awal adalah 4 dan nilai kiri adalah 2, sehingga nilai k = awal-1 = 3 dan batas akhirnya adalah
k ≥ 2 (k ≥ kiri).

Untuk k = 3, maka array[3+1] akan menempati array[3]. Dapat dilihat bahwa array[4] adalah
7 dan array[3] adalah 11, sehingga array[4] kini bernilai sama dengan array[3] yaitu 11. Setelah
array[4] kini bernilai 11, perulangan for akan kembali melakukan pengecekan.
 Indeks ke- 0 1 2 3 4

Data 4 6 9 11 11

Untuk k = 2, maka array[2+1] akan menempati array[2]. Dapat dilihat bahwa array[3] adalah
11 dan array[2] adalah 9, sehingga array[3] kini bernilai sama dengan array[2] yaitu 9. Setelah
array[3] kini bernilai 9, perulangan for akan kembali melakukan pengecekan.

Indeks ke- 0 1 2 3 4

Data 4 6 9 9 11

Ternyata perulangan for kini sudah bernilai false, sebab batas awal adalah k=3 dan batas akhir
adalah k≥2 dan nilai k sudah mencapai k=2. Program melanjutkan ke baris 22

Baris ke-22 kemudian menyatakan array[kiri] = temp, sehingga array[2] akan sama dengan
nilai yang disimpan pada variabel temp yaitu 7. Sehingga urutannya menjadi sebagai berikut

Indeks ke- 0 1 2 3 4

Data 4 6 7 9 11

Perintah baris ke-23 hingga 25 akan dieksekusi dimana variabel kiri, akhir, dan awal akan
melakukan increment sebesar 1. Nilai kiri menjadi 3, akhir menjadi 4, dan awal menjadi 5.
Program kembali ke perulangan while. Pengecekan kembali dilakukan apakah kiri ≤ akhir dan
awal ≤ kanan. Ternyata nilai 3 ≤ 4 (kiri ≤ akhir) dan nilai 5 ≤ 4 (awal ≤ kanan) bernilai false,
sehingga perulangan while berhenti. Data pun sudah terurut dengan benar.

Apabila dibuat skemanya, maka algoritma divide & conquer adalah sebagai berikut

9 6 11 4 7

divide to sub-problem divide to sub-problem

9 6 11 4 7

conquer sub-problem conquer sub-

problem
 6 9 11 4 7

Conquer then combine conquer then combine

4 6 7 9 11

Hasil Run Program

Analisis Running Time Merge Sort

Merge sort selalu membagi setiap array menjadi dua sub-array hingga mencapai
basis, sehingga kompleksitas dari algoritma merge sort, berlaku untuk semua kasus (Worst
Case = Best Case = Average Case).

Untuk memudahkan, kita anggap jumlah elemen array (n) adalah kelipatan 2, jadi
setiap dilakukan divide (pemecahan menjadi dua sub-array), kedua sub-array akan berukuran
n/2.

 Basis : untuk n = 1, maka array tersebut sudah terurut dengan sendirinya.

 Rekurens : untuk n > 1, maka akan dilakukan langkah-langkah merge sort, yaitu :
 Divide : Hitung nilai q yang merupakan rata-rata dari p + r, yang bernilai Θ(1).
 Conquer : Secara rekursif menyelesaikan 2 sub-array, setiap sub-array
berukuran n/2, maka bernilai 2T(n/2).
 Combine : Menggabungkan element dari sub-array ke dalam array dengan
prosedur MERGE, bernilai Θ(n).

Kompleksitas waktu tersebut dapatk dijelaskan dari recursif tree berikut :

 Array awal (cn), yang memiliki dua sub-array, masing-masing bernilai T(n/2).
 cn

T(n/2) T(n/2)

 Kemudian sub-array tersebut di bagi lagi menjadi dua sub-sub-array, jadi bernilai
T(n/4) dan seterusnya.
cn

cn/2 cn/2

T(n/4) T(n/4) T(n/4) T(n/4)

 Di dapatkan tinggi pohon rekursif adalah log n, dan memiliki sebanyak log n + 1
level. Setiap level bernilai cn, sehingga cn log n + cn.
 Koefisien c tidak perlu di masukkan, sehingga kompleksitas waktunya menjadi T(n)
= O(n log n)
 BAB III
PENUTUP

A. Kesimpulan
Dari penjelasan diatas, maka dapat diratik kesimpulan mengenai algoritma divide dan
conquer yaitu :
1. Algoritma divide dan conquer sudah lama diperkenalka sebagai sumber dari
pengendalian proses parallel, karena masalah-masalah yang terjadi dapat diatasi
secara independent. Banyak arsitektur dan bahasa pemrograman parallel
mendesain implementasinya (aplikasi) dengan struktur dasar dari algoritma
divide dan conquer.

2. Penerapan algoritma dapat dipakai untuk sorting (quicksort, binary sort),

computational geometry, graph theory, numerical dan not data parallel.

3. Keuntungan menggunakan algoritma divide dan conquer adalah dapat

memecahkan permasalahan yang sulit, lebih efisien, parallel atau sub masalah
dapat dijalankan pada processor yang berbeda serta akses memori setiap sub
masalah diselesaikan cukup mengakses cache memory yang tidak terlalu
lambat.
B. Saran
Penulis sadar bahwa makalah ini jauh dari kesempurnaan, maka dari itu enulis
mengharapkan kritik dan saran yang membangun demi perbaikan makalah ini sehingga
makalah ini menjadi makalah yang baik dan berguna khususnya dalam ruang lingkup
pendidikan.