Diktat

Strategi Dan Analisis Algoritma

Rev.2.0 - 2012

Disusun Oleh
Wijanarto, M.Kom

Fakultas Ilmu Komputer

Universitas Dian Nuswantro
Semarang
2012
1
 Kata Pengantar

Pada revisi dua ini diktat Strategi dan analisa algoirtma, mengalami perubahan mayor,
yaitu update sebanyak 2 bab, yang diletakan pada bab 2, Overview analisa algoritma dan 3,
Notasi asimtotik. Pada revisi sebelumya tidak ada, revisi ini di buat karena selama buku pada
revisi 1 di ajarkan siswa kurang kuat memahami erhitungan kompleksitas algoritma,
dikarenakan dasar pemahaman pembacaan algoritma kurang bagus. Dua bab yang di
tambahkan bertujuan sebagai dasar memahami bab selanjutnya, khususnya kompleksitas
algoritma dan notasi asimptotik. Selain itu juga di berikan beberapa contoh persoalan pada
bab-bab tertentu, dan akan berkembang terus, karena pada dasarnya buku ini jauh dari
kesempurnaan. Kedepan, tiap tahunnya akan di lakukan revisi, baik mayor maupun minor
sekuat tenaga, untuk memajukan pendidikan tinggi indonesia.

Semarang, 2012.

wijanarto

2
 Daftar Isi
BAB I.......................................................................................................................................................... 7

STRATEGI DAN ANALISA ALGORITMA .......................................................................................................... 7

1.1. PENDAHULUAN .......................................................................................................................................7

1.2. REVIEW ALGORITMA ...............................................................................................................................8
1.3. KOMPONEN ALGORITMA .....................................................................................................................10
1.4. STRATEGI DAN ANALISIS ALGORITMA ..................................................................................................10
1.4.1 STRATEGI ALGORITMA .................................................................................................................10
1.4.2 ANALISIS ALGORITMA...................................................................................................................11
1.4.3 TAHAPAN PEMECAHAN MASALAH .............................................................................................11
1.4.4 STRUKTUR DASAR ALGORITMA ..................................................................................................11
1.4.4.1. SEKUENSIAL...............................................................................................................................12
1.4.4.2. BRANCHING ...............................................................................................................................12
1.4.4.3. LOOPING ....................................................................................................................................13
1.5. ASPEK ALGORITMA................................................................................................................................14
1.6. BACKGROUND MATEMATIKA................................................................................................................15

BAB II....................................................................................................................................................... 22

OVERVIEW ANALISA ALGORITMA.............................................................................................................. 22

2.1. PENDAHULUAN .....................................................................................................................................22

2.2. PROBLEM DAN SOLUSI ..........................................................................................................................22
2.3. FRAMEWORK ANALISA ALGORITMA .....................................................................................................24
2.3.1. PEMODELAN SUATU KOMPUTER. .........................................................................................24
2.3.2. DEFINISI FORMAL DAN INFORMAL TERMINOLOGI DASAR...............................................25
2.3.3. MODEL MATEMATIKA PADA KOMPUTER .............................................................................25
2.3.4. PERBANDINGAN RAM DENGAN KOMPUTER ATAU KOMPILER NYATA ...........................29
2.4. STRATEGI UMUM ANALISA ALGORITMA ...............................................................................................30
2.5. CONTOH PROBLEM ...............................................................................................................................31

BAB III...................................................................................................................................................... 36

NOTASI ASIMTOTIK .................................................................................................................................. 36

3.1. PENDAHULUAN .....................................................................................................................................36

3.2. DEFINISI.................................................................................................................................................37
3.2.2. Notasi “Big Oh” ATAU “O” ......................................................................................................38
3.2.3. TEOREMA DALAM NOTASI BIG OH ATAU “O” .....................................................................40
3.2.4. NOTASI OMEGA (Ω)...................................................................................................................42
3.2.5. NOTASI THETA (Θ) ....................................................................................................................43
3.3. RINGKASAN ...........................................................................................................................................46

BAB IV...................................................................................................................................................... 50

KOMPLEKSITAS WAKTU DAN EFISIENSI...................................................................................................... 50

4.1. PENDAHULUAN .....................................................................................................................................50

3
 4.2. PENGUKURAN .......................................................................................................................................50
4.2.1. EFISIENSI WAKTU .....................................................................................................................51
4.2.2. EFISIENSI SPACE MEMORI ......................................................................................................54
4.2.3. KEMUDAHAN IMPLEMENTASI ................................................................................................55
4.2.4. DATA MOVEMENT (SORTING) .................................................................................................55
4.2.5. STABILITY (SORTING) ...............................................................................................................55
4.3. EFISIENSI ALGORITMA...........................................................................................................................56
4.4. SPACE DAN MEMORY ............................................................................................................................57
4.4.1. PROCEDURE/FUNCTION CALL ...............................................................................................58
4.4.2. STRUKTUR PROGRAM ..............................................................................................................58
4.4.2.1. OPERATOR, ARRAY DAN POINTER .........................................................................................59
4.4.2.2. SEKUENSIAL...............................................................................................................................59
4.4.2.3. BRANCHING ...............................................................................................................................60
4.4.2.4. LOOPING ....................................................................................................................................61
4.4.2.4.1. FOR LOOP KASUS 1 ..............................................................................................................61
4.4.2.4.2. FOR LOOP KASUS 2 ..............................................................................................................62
4.4.2.4.3. FOR LOOP KASUS 3 ..............................................................................................................63

BAB V ...................................................................................................................................................... 66

RECURSIVE CALL ....................................................................................................................................... 66

5.1. BEPIKIR REKURSIF..................................................................................................................................66

5.2. PEMANGGILAN FUNGSI REKURSIF........................................................................................................66

BAB VI ALGORITMA BRUTEFORCE ............................................................................................................. 70

5.1. SELECTION SORT ...................................................................................................................................70

5.2. BUBBLE SORT ........................................................................................................................................71
5.3. SEQUENTIAL SEARCH ............................................................................................................................71
5.4. STRING MATCHING ...............................................................................................................................72
5.5. DUA TITIK TERDEKAT .............................................................................................................................76
5.6. MENGHITUNG FAKTORIAL (N!) .............................................................................................................76
5.7. PERKALIAN MATRIK N*N .......................................................................................................................77
5.8. MASALAH KOMBINATORIAL..................................................................................................................77

BAB VII..................................................................................................................................................... 80

ALGORITMA GREEDY ................................................................................................................................ 80

7.2. KARAKTERISTIK ALGORITMA GREEDY...................................................................................................81
7.3. IMPLEMENTASI AG................................................................................................................................83
7.3.1. REVIEW GRAPH .................................................................................................................................83
7.3.2. INDEGREE DAN OUTDEGREE .................................................................................................84
7.3.3. GRAPH TIDAK BERBOBOT .......................................................................................................88
7.3.4. GRAPH BERBOBOT....................................................................................................................90
7.3.5. PATH............................................................................................................................................91
7.3.6. CYCLE .........................................................................................................................................92
7.3.7. GRAPH TERHUBUNG ................................................................................................................92

4
 7.3.8. TREE ............................................................................................................................................92
7.4. MINIMUM SPANNING TREE (MST) ........................................................................................................93
7.4.1. ALGORITMA KRUSKAL .............................................................................................................93
7.4.2. ALGORITMA PRIM .....................................................................................................................97
7.4.3. SHORTEST PATH : ALGORITMA DIJKSTRA..........................................................................102
7.4.4. SHORTEST PATH : ALGORITMA KNAPSACK........................................................................104
7.4.4.1. SECARA MATEMATIS...............................................................................................................104
7.4.4.2. SECARA GREEDY .....................................................................................................................105

BAB VIII.................................................................................................................................................. 109

ALGORITMA DIVIDE AND CONQUER ........................................................................................................ 109

8.1. DEFINISI...............................................................................................................................................109
8.2. RUNNING TIME DARI ALGORITMA DIVIDE DAN CONQUER ................................................................111
8.3. TEOREMA MENCARI O(F(N)) UNTUK METODE D AND C ......................................................................114
8.4. ALGORITMA SORTING .........................................................................................................................114
8.4.1 INSERTION SORT .................................................................................................................................114
8.4.2 SELECTION SORT .................................................................................................................................116
8.4.3 BUBBLE SORT ......................................................................................................................................118
8.4.4 SEQUENTIAL SORT...............................................................................................................................119
8.4.5 MERGE SORT .......................................................................................................................................121
8.4.6 QUICK SORT ........................................................................................................................................124
8.5. ALGORITMA SEARCHING.....................................................................................................................126
8.5.1 SEQUENTIAL SEARH ...................................................................................................................126
8.5.2 BINARY SEARH .............................................................................................................................130
8.5.3 INTERPOLATION SEARH .............................................................................................................132

BAB IX.................................................................................................................................................... 137

ALGORITMA BASIS GRAPH ...................................................................................................................... 137

10.1. DEPTH FIRST SEARCH (DFS) .................................................................................................................137

9.1.1. REPRESENTASI LARIK DAN LINK LIST .................................................................................138
9.1.2. MEMBUAT MATRIK KETERHUBUNGAN...............................................................................139
10.2. BREADTH FIRST SEARCH (BFS) .............................................................................................................142
10.3. HILL CLIMBING ....................................................................................................................................148
10.4. BEST FIRST SEARCH.............................................................................................................................150
10.5. A* (A-START) .......................................................................................................................................151
10.6. TERMINOLOGY ....................................................................................................................................152

BAB X..................................................................................................................................................... 154

BACKTRACKING ...................................................................................................................................... 154

10.1. TEKNIK BACKTRACKING.......................................................................................................................154

10.4.2. SOLVING MAZE ...............................................................................................................................155
10.4.3. PEWARNAAN PETA .........................................................................................................................156
10.4.4. SOLVING PUZZLE .............................................................................................................................159
10.1. EIGHT PUZZLE......................................................................................................................................159
5
 10.2. QUEEN PROBLEM ................................................................................................................................160
10.3. BISHOP PROBLEM ...............................................................................................................................161
10.4. KINGS PROBLEM..................................................................................................................................162
10.5. KNIGHT PROBLEM ...............................................................................................................................163
10.6. ROOK PROBLEM ..................................................................................................................................164
10.5. DISAIN SOLUSI DALAM PENGKODEAN ................................................................................................165
10.6. PROBLEM DAN SOLUSI ........................................................................................................................166

DAFTAR PUSTAKA................................................................................................................................... 170

6
 BAB I
STRATEGI DAN ANALISA ALGORITMA

1.1. PENDAHULUAN
Di dalam disiplin ilmu komputer, pembahasan strategi dan analisis terhadap suatu
algoritma, yaitu suatu masalah merupakan trigger untuk membuat atau memilih strategi yang
tepat dalam menyelesaikannya menjadi topic penting. Jadi bagaimana kita akan
menyelesaikan suatu masalah adalah pekerjaan pertama sebelum di tuangkan dalam suatu
bahasa. Pemahaman struktur data dan algoritma dengan di dukung penguasaan suatu bahasa
tertentu, sehingga akan lebih mudah di komunikasikan dengan komputer dalam penyelesaian
masalah tersebut, menjadi prasyarat utama dalam kuliah ini. Syarat utama dalam mengikuti
dan mempelajari buku ini, adalah mahasiswa sudah pernah menempuh mata kuliah dasar
pemrograman, algoritma dan pemrograman, struktur data dan matematika diskrit.
Penerapan cara pembelajaran pada matakuliah Strategi dan Analisis Algoritma secara
umum ditujukan untuk memberikan pembekalan kepada mahasiswa dalam berfikir secara
logis, kritis, kreatif dan analitis dalam memecahkan masalah berbasis program komputer.
Secara khusus pada matakuliah kedepan akan diberikan ketrampilan baru dalam hal
pengukuran efisiensi dan waktu tempuh suatu algoritma, yaitu mengukur seberapa efisien
langkah-langkah serta berapa banyak waktu yang di perlukan untuk pemecahan suatu
masalah. Disamping itu kemampuan kepemimpinan (leadership) dan kemampuan bekerja
sama dalam sebuah kelompok (team work) juga akan ditanamkan melalui tugas-tugas
kelompok dan presentasi-pesentasi tugas terstruktur baik dalam hal penguasaan audiens,
menjawab pertanyaan maupun penyampaian materi. Hal tersebut sesuai dengan tujuan
pendidikan bidang ilmu komputer diantaranya adalah mempunyai pengetahuan dan
ketrampilan yang cukup untuk bekerja dalam bidang-bidang yang menyangkut pengelolaan
komputer maupun penggunaan dan pemanfaatan dalam bidang teknologi informasi.
Pada bagian ini, akan di berikan bekal dasar pemahaman mengenai Konsep Strategi dan
Analisis algoritma, tujuan utama dari bab ini supaya mahasiswa dapat memahami Algoritma
dan Struktur Dasar Algoritma, serta mampu mengidentifikasikan dan menjelaskan definisi
dasar strategi dan analisis algoritma. Sedangkan pokok bahasan yang menjadi topik utama

7
adalah mengenai review algoritma, komponen algoritma, Konektifitas Strategi dan Analisis
algoritma serta latar belakang untuk memahaminya secara matematis. Setelah mempelajari
bab ini, di harapkan mahasiswa dapat menjelaskan dan membedakan definisi dasar strategi
dan analisa algoritma, serta memanfaatkan dalam dunia pemrograman.

1.2. REVIEW ALGORITMA

Di dalam disiplin ilmu komputer, dalam bahasan strategi dan analisis terhadap suatu
algoritma, dimana suatu masalah merupakan trigger untuk membuat atau memilih strategi
yang tepat dalam menyelesaikannya. Jadi bagaimana kita akan menyelesaikan suatu masalah
adalah pekerjaan pertama sebelum di tuangkan dalam suatu bahasa. Pemahaman struktur data
dan algoritma dengan di dukung penguasaan suatu bahasa tertentu, sehingga akan lebih mudah
di komunikasikan dengan komputer dalam penyelesaian masalah menjadi prasyarat utama
dalam membahas kuliah ini. Jadi selanjutnya pembaca akan di anggap sudah pernah
menempuh dan lulus mata kuliah di atas.

Kembali ke suatu masalah, kita dapat saja menyelesaikannya dengan cara Langsung
kerjakan, Tebak dan untung-untungan, Trial error, Pengalaman , "Scientifically“ (secara
ilmiah ). Pilihan tergantung pada kita, akan tetapi dalam kuliah ini kita akan mendekati secara
ilmiah, dimana terdapat urut-urutan langkah tertentu yang harus di kerjakan. Prinsip umum
yang paling mudah di mengerti dalam proses memecahkan masalah adalah melakukan
analisis, disain, implementasi dan kompilasi.

Tentu saja urutan di atas dilakukan berbasis komputer. Pada saat menganalisis kita harus
menentukan masalah yang di hadapi, sedang pada tahap disain kita sudah dapat menentukan
algoritma mana yang harus dipakai dalam rangka pemecahan masalah tersebut. Implementasi
merupakan tahap koding, dan debugging, dan terakhir adalah mengkompilasi penyelesaian
masalah dalam bentuk yang di mengerti komputer.

Secara mendasar maka dapat di katakan bahwa penyelesaian masalah dalam kuliah ini
adalah seperti gambar 1 di bawah ini. Penyelesaian suatu masalah di awali dengan adanaya
masalah itu sendiri untuk di analisa, dimana kita dapat melakukan penyataan, menurunkan,
memvalidasi masalah tersebut untuk di disain penyelesaiannya. Disain algoritma selanjutnya

8
harus di ekspresikan menjadi suatu program untuk dilakukan pengujian apakah sudah
mendapatkan solusi dari masalah yang ada.

MASALAH

ANALISA MASALAH MENURUNKAN

MENYATAKAN
MEMVALIDASI
MENGANALISA
DISAIN ALGORITMA

PROGRAM KOMPUTER

UJI HASIL DAN DOKUMENTASI

SOLUSI
MASALAH
Gambar 1. Diagram Proses Penyelesaian Masalah

Sehingga dari paparan di atas kita menjadi tahu di mana letak kuliah ini, yaitu
mencoba menyelelesaikan masalah melalui pemilihan algoritma, dan dengan ini maka kita
akan review mengenai algoritma itu sendiri. Untuk mempersingkat ruang dan waktu maka
secara sederhana maka definisi Algoritma adalah Kumpulan atau himpunan langkah-langkah
yang berhingga untuk menyelesaikan masalah dengan menggunakan komputer, dengan
aturan:

a) Setiap step/langkah harus DEFINITE (pasti).

X ← x + (1 atau 2) // Undefinite
x ← x + (Random(2) + 1) //Definite
b) Minimum mempunyai 1 buah Output (Input boleh tidak ada).
c) Harus ada Stoping Criteria atau dengan kata lain, harus bisa berhenti.
X←0
Repeat
write (x)
x←x+2
until x = 15
//tidak berhenti, jadi stoping criterianya salah

9
1.3. KOMPONEN ALGORITMA
Suatu algoritma dapat saja terdiri dari beberapa komponen pokok, dimana komponen ini
menentukan suatu algoritma akan bekerja, di antaranya adalah :

 Statement Output / Input

write (x) read(x)
return x input x
print x scan x
cetak(x) baca(x)
 Operasi(Process)
Operasi Dasar :
 Aritmatik ( * , / , Mod, Div, +, - ,abs, ceil, floor)
 Relasi ( <, >, ≤, ≥, =, ≠ )
 Logika ( and, or, not )
 Assignment ( ← )
 Pengendali Proses
 Percabangan : if, if .... else, case
 Perulangan : for, while, do while, repeat .... until.

Untuk bahasan yang lebih detail akan di berikan pada kuliah selanjutnya. Dengan demikian
ada suatu transformasi dari suatu algoritma menjadi suatu program dengan memanfaatkan
bahasa tertentu dan mengolah komponen algoritma yang ada dan di harapkan dapat
menyelesaikan masalah yang di hadapi.

1.4. STRATEGI DAN ANALISIS ALGORITMA

Beberapa definisi dan terminology dalam kuliah ini akan di berikan secara ringkas
guna memahami konsep yang lebih penting dalam pertemuan selanjutnya. Definisi dan
konsep dari kuliah ini adalah Strategi, Analisis dan Algoritma itu sendiri.

1.4.1 STRATEGI ALGORITMA

Strategi merupakan rencana yang cermat mengenai kegiatan untuk mencapai sasaran
khusus, sedangkan Algoritma adalah urutan langkah-langkah untuk memecahkan suatu
masalah. Dengan demikian Strategi algoritmik adalah kumpulan metode atau teknik untuk
memecahkan masalah guna mencapai tujuan yang ditentukan, yang dalam hal ini deskripsi
metode atau teknik tersebut dinyatakan dalam suatu urutan langkah-langkah penyelesaian.
10
1.4.2 ANALISIS ALGORITMA
Analisis berhubungan dengan cara pandang kita terhadap seberapa cepat algoritma itu
bekerja (waktu tempuh) dan perlu berapa banya sumber daya (memori). Dengan menganalisis
suatu algoritma, diharapkan akan mendapatkan strategi yang tepat untuk memilih algoritma
dalam menyelesaikan masalah. Dengan demikian Analisis algoritma adalah salah satu
tahapan dari perancangan algoritma, Sedangkan perancangan algoritma adalah salah satu
tahapan dari proses pemecahan masalah dengan komputer.

1.4.3 TAHAPAN PEMECAHAN MASALAH

Dari tahapan penyelesaian masalah di atas sebelumnya maka kita dapat memecah
menjadi beberapa bagian dimana masing-masing tahap mempunyai bobotnya sendiri-sendiri.
Walaupun sebenarnya pembobotan tersebut dapat di kombinasikan secara kasuistis tetapi
secara umum dalam modul ini akan di paparkan sebagai berikut :

• Analisis Masalah (40%)

– Analisis masalah adalah kegiatan mempelajari, mendalami masalah hingga
mendapatkan ide-ide penyelesaian masalah (ide global).
• Perancangan Algoritma (30%)
– Perancangan algoritma adalah pembuatan algoritma dimulai dari ide-ide
penyelesaian masalah hingga terciptanya algoritma dalam bentuk standar (a.l.
pseudocode).
• Pembuatan Program Komputer (20%)
– Mentransfer algoritma menjadi kode program, yang sebelumnya perlu
ditentukan struktur datanya.
• Pengujian Hasil Program (5%)
– Running program untuk mengetahui apakah ada kesalahan, baik kesalahan
sintax, running atau output/hasil.
• Pembuatan Dokumentasi Program (5%)
– Pembuatan dokumentasi meliputi dokumentasi dalam program atau manual
petunjuk pemakaian dan pemeliharaan program.
1.4.4 STRUKTUR DASAR ALGORITMA
Setidaknya ada tiga struktur dasar algoritma yang perlu di pahami untuk kebutuhan
studi ini (dan studi pemrograman). Struktur ini sangat berkaitan dengan tahapan penyelesaian
masalah, yaitu tahap perancangan algoritma dan implementasi dalam program komputer.
Struktur ini berlaku umum pada hampir di semua teknik pemrograman, baik dalam paradigma
imperatif, object oriented bahkan fungsional dan simbolik.

11
1.4.4.1. SEKUENSIAL
Struktur sekuensial merupakan urutan suatu proses dimana langkah suatu proses
tersebut di lakukan secara berurutan, dan tidak dapat saling tumpang tindih, artinya suatu
langkah mempunyai inisial awal yang akan dapat di kerjakan oleh langkah berikutnya,
sebaliknya langkah terakkhir hanya di dapat apabila urutan langkah sebelumnya di kerjakan
dengan benar. Ini merupakan konsep dasar dalam pemrograman prosedural atau top-down
programming. Secara ilustratif maka struktur sekuensial dapat di gambarkan dalam bagan di
gambarkan sebagai berikut :
Langkah ke-1







Langkah ke-n

Gambar 2. Struktur Sekuensial

1.4.4.2. BRANCHING
Pencabangan atau branching merupakan struktur dasar algoritma lainnya yang
memegang peranan penting baik dalam disain suatu program atau disain hardware (optimasi
kompilasi). Karena pada level rendah suatu program atau algoritma nanti di proses secara
sekuensial (dalam assembli) dan pencabangan merupakan hal yang mempengaruhi kecepatan
pemrosesan (oleh prosesor dan memori).

Pencabangan merupakan suatu struktur yang paling sering di pakai dalam algoritma
dan merupakan otak dari algoritma itu sendiri, karena pemilihan langkah selanjutnya
merupakan hasil analisa dari struktur ini. Pengambilan keputusan untuk melaksanakan
perintah atau pernyataan berawal dari adanya suatu kondisi yang di berikan oleh struktur
branching ini. Biasanya suatu kondisi hanya bernilai benar atau salah dari suatu pernyataan
12
dalam bentuk logika atau relasional dari suatu operasi yang di berikan. Oleh karena itu
memahami operasi dan operator baik dalam algoritma atau pemrograman menjadi penting.
Dalam gambar 1.3 di bawah ini di berikan ilustrasi bagan pencabangan atau sering juga di
sebut kondisional.

Gambar 3. Struktur Pencabangan

Secara notasi seringkali di berikan dengan IF (Kondisi) THEN (AKSI 1) ELSE (AKSI
N). Variasi pencabangan dapat di bagi secara nested dan cascade. Pencabangan cascade
merupakan pencabangan yang terstruktur seperti bertumpuk. Sedangkan pencabangan nested
merupakan pencabangan yang di dalamnya ada pencabangan lainnya begitu seterusnya. Di
bawah ini di berikan gambaran mengenai maksud dari kedua hal tersebut.

if (k1) then a1 if (k1) then {

else if (k2) then a2 if (k2) then {
else if (k3) then a3 if (k3) then a3
else if(k4) then a4 else a4
else if (k5) then } else {
a5 if (k5) then a5
. } else {
. }
.
.
else an
(a) (b)

Gambar 4. Pencabangan cascade(a) dan nested (b)

1.4.4.3. LOOPING
Perulangan atau looping atau kalang merupakan bagian dari struktur algoritma dasar
lainya yang penting. Di katakan demikian karena kita sering mengulang sesuatu operasi atau
pernyataan yang sifatnya repetitif dan banyak. Dengan demikian, berhubungan dengan suatu
13
perulangan, struktur ini memberi keleluasaan pada kita untuk mengulang suatu proses tanpa
pernah salah dan lelah. Perulangan dapat di notasikan dengan berbagai macam cara, tetapi
yang umum adalah REPEAT.....UNTIL (KONDISI), WHILE (KONDISI) DO dan FOR
AWAL TO AKHIR DO. Secara algoritmik kita dapat menyesuaikan dengan bahasa

yang akan kita pakai. Notasi di atas mirip dengan bahasa pascal, apabila kita dekatkan
ke bahasa C maka akan menjadi do.....while(kondisi), while(kondisi) dan for (awal;akhir;step).
Sedangkan ilustrasi dari perulangan secara flow chart dapat di gambarkan seperti gambar 1.5
di bawah ini.

Gambar 5. Perulangan atau Looping

1.5. ASPEK ALGORITMA

Suatu Algoritma mempunyai beberapa aspek yang mendukungnya, aspek-aspek inilah
yang akan mengkonstruksi suatu algoritma sedemikian rupa sehingga algoritma dapat di
katakan stabil, dapat menyelesaikan masalah dan berjalan sesuai dengan harapan apabila
memenuhi :

• Validitas
Algoritma harus benar, artinya memberikan keluaran yang di kehendaki
• Efektifitas
Tepat guna, hasil guna, akurat, mencapa tujuan, aman , kebenaran algoritma tersebut
merespon terhadap inputan apapun
• Efisiensi

14
 Hemat, Cepat dengan space memori yang kecil , Space yang di perlukan
Waktu/banyak langkah atau waktu tempuh yang di gunakan oleh :
• Banyaknya statement
• Jenis statement/struktur
• Banyak operasi aritmatik dan logik
• Procedure dan fungsi call
• Built-in function
• User define
• Recursif
• Non recursive
• Berhingga langkahnya
Suatu agoritma akan berhenti pada suatu saat
• Logis dan terstruktur
Urutan langkahnya dapat di pertanggungjawabkan, artinya rumusan solusi berdasarkan
logika, tidak coba-coba. Setiap langkah yang ada dalam algoritma tersebut terstruktur
dengan baik, artinya tidak ada langkah yang saling overlap satu dengan lainnya
(menghindari pemakaian goto) .

Jadi Suatu Analisis algoritma adalah studi mengenai waktu dan ruang terhadap suatu
algoritma, dimana waktu di ukur melalui kecepatan pemrosesan yang di bandingkan dengan
kebutuhan ruang memori pada algoritma tersebut. Memori di pengaruhi oleh pemakaian
variable, pemanggilan fungsi dana pemakaian stack dalam pemroses. Sedangkan kecepatan
tergantung pada peralatan utama yang mungkin, misalnya cache memori, jumlah langkah
algoritma, jumlah operasi (operand an operator). Kebutuhan ruang/space dan kecepatan
(waktu tempuh) inilah yang di sebut sebagai KOMPLEKSITAS ALGORITMA. Space
sering unpredicted, terutama jika pemakaian pointer dominan dan biasanya space tidak di
libatkan dalam analisis algoritma secara langusng kecuali tipe data yang di pakai adalah tipe
data statis. Sedang Strategi algoritma adalah bagaimana merencanakan atau menentukan
suatu model penyelesaian masalah, untuk itu perlu di buat disain yang memenuhi aspek
algoritma yang di maksud, serta bagaimana memilih model penyelesian masalah yang sudah
ada sehingga di pandang dapat dengan tepat untuk itu.

1.6. BACKGROUND MATEMATIKA

1.6.1. INDUKSI MATEMATIKA
Adalah metode pembuktian suatu statement yang melibatkan ilangan asli, missal suatu
statemen P(n), dengan n  N. Induksi matematika akan membuktikan bahwa P(n) benar atau berlaku
untuk semua bilangan asli kecuali beberapa :

15
 a. Ada n0  N sehingga P(n0) benar
b. Untuk setiap n  n0, jika P(n) benar maka P(n+1) juga benar

Atau secara formal, prinsip induksi matematika dapat di jelaskan sebagai berikut,
missal untuk P(n) yang merupakan pernyataan yang di definisikan dalam bilangan bulat n dan
misalkan a adalah bilangan bulat tetap, maka pernyataan tersebut benar :
a. P(a) Benar, ini di sebut sebagai langkah basis.
b. Jika P(n) benar maka p(n+1) benar untuk na, ini di sebut sebagai langkah
induksi.
Contoh :

1
P(n)=1+2+3+4+…+n= n( n  1)
2
1
P(1)=1= .1(1  1) , adalah BENAR (basis)
2
n1 dan P(n) adalah BENAR, maka
1
P(n)=1+2+#+4+…+n= n( n  1) adalah BENAR
2
1
P(n+1)=1+2+#+4+…+n+(n+1) = n( n  1) +(n+1) (induksi)
2
1
= (n+1)(n+2)
2
1
= (n+1)((n+1)+1), juga BENAR
2

1.6.2. FUNGSI
Fungsi adalah dua himpunan elemen, A dan B, dan aturan f, yang meerupakan pemetaan
untuk setiap elemen dalam A, pada salah satu unsur dalam B. Suatu fungsi dinotasikan sebagai
f: A  B. Pemetaan dari suatu himpunan A ke himpunan B yang memenuhi syarat :
a. Jika a1,a2 A, dan b1,b2B, serta b1 peta a1 dan b2 peta a2, dan jika a1=a2, maka
b1=b2.
b. Setiap aA dan bB, sehingga b merupakan peta dari a, di gambarkan sebagai

a1 b1
a3 b2
a4 b5
Nilai fungsi di a4 dan a2

Gambar 6. Pemetaan Fungsi

16
Jika b merupakan peta di a terhadap himpunan f, maka b di sebut nilai fungsi dari f di a, dan
ditulis b=f(a) atau f(a)=b. Penyajian fungsi dari gambar di atas dapat di berikan sebagai
berikut :
a. b merupakan ekspresi aritmatika atau logika yang melibatkan a dan konstanta, atau
fungsi dalam a.
b. disajikan dalam suatu algoritma
contoh :
f(n)= n2
s(n): if n=1 then s=1 else s:=2n+s(n-1)-1
f(n): if n=1 then f:=1 else
t:=1
for i:=1 to n do
t:=t2+i
f:=t;
fakto (n)
if n=0 then fakto:=1 else
fakto:= n*fakto(n-1)

p(n):fakto(n)=n!

f(a)=b

Var Bebas var tak bebas

1.6.3. BARISAN
Merupakan fungsi dengan himpunan asal berupa bilangan asli, jika an merupakan nilai
fungsi f di n, maka an=f(n) dan dapat ditulis an n  1,2,3,... disebut dengan BARISAN.

Contoh 1 :
1
an = f(n) =
n2
1 1 1 1
Barisannya adalah , , , ,…
1 2 2 2 32 4 2

Contoh 2:
an=f(n)=f(n-1)+f(n-2), untuk n3, maka barisannya adalah
a1=f(1)=1
a2=f(2)=1, jadi
a1,a2,a3,a4,a5,a6,…
1,1,2,3,5,8,13,21,…
Di sebut sebagai barisan Fibonacci.
17
Contoh 3:
n , n  1,2
a n  f ( n)  
3( f (n  2)) 2 , n  3
a1=1, a2=2,a3=3(f(1))2=3
a4=3(f(2))2=3X22=12
a5=3(f(3))2=3X32=27,…
barisannya adalah 1, 2, 3, 12, 27, 432,…..
1.6.4. DERET
Merupakan barisan dalam bentuk jumlahan barisan.
Contoh 1
Di ketahui barisan a1, a2 ,a3 ,a4 ,…, an,…
DERET1= a1,a1+a2,a1+a2+a3,…
DERET2=a1,a2,a1+a3,a2+a4,a1+a3+a5,a2+a4+a6,….
n
Maka deret1 dapat di tulis sebagai S n   a i dan
i 1

n
 a 2 i , n  genap
 i 1
Deret2 dapat di tulis sebagai S n   n 1
2
 a 2i 1 n  gasal
 i 1
Pada barisan maupun deret ada yang mempunyai konvergen atau divergen ke suatu
nilai, konvergen adalah apabila barisan atau deret tersebut menuju ke suatu nilai dan divergen
berarti barisan atau deret tersebut nilainya menyebar. Untuk barisan atau deret tak hingga
untuk menentukan konvergensi barisan atau deret tersebut di gunakan limit untuk barisan atau
deret.

1.6.5. KONVERGENSI BARISAN

Misalkan di ketahui suatu barisan {an} dengan an=f(n), maka barisan an di katakan
konvergen ke L apabila :
lim f (n)  L atau
n 

an cenderung ke nilai L, dimana LR

Contoh 1
 n  1 2 3 4
barisan   : , , , ,…
 n  1 2 3 4 5
n
f(n)=
n 1

18
Cara mencari konvergensinya adalah
n n 1 1 1
lim f (n)  lim :  lim
n  n  1 n 1

1 0
 1 , ingat =0.

n  n 
1
n
 n 
Jadi   konvergen ke 1
 n  1
Contoh 2
 n 2  1 4 9 16
Barisan   = , , , ,…
 n 1 2 3 4 5
n2
f(n)=
n 1
n2 n n 
lim f ( n)  lim :  lim
n  1 n n

1 1 0

n n
1
n
 n2 
Jadi   tidak konvergen.
 n 1
Contoh 3
Barisan (1) n =-1,1,-1,1,-1,1,-1,….??? Ini adalah barisan yang tidak konvergen
Teorema
Misalkan f(n) konvergen ke L1 dan g(n) konvergen ke L2, maka
F(n)g(n) konvergen ke L1L2
k.f(n) konvergen ke L1
f(n)*g(n) konvergen ke L1*L2
f ( n) L1
konvergen ke , untuk L20
g ( n) L2
Khusus untuk perkalian dan pembagian (* dan /) jika salah satu fungsinya tidak
konvergen, BELUM tentu hasilnya tidak konvergen, bias saja hasilnya konvergen.
Contoh
1
f(n)=n, g(n)=
n 1
lim f (n)  lim n   , tidak konvergen
n  n 

1 1
lim g (n)  lim n  1    0 , konvergen ke 0
n  n 

1 n 
An=f(n)*g(n)=n* = , jelas konvergen ke 1, karena 1
n 1 n 1 

19
 n
Jadi barisan { }konvergen ke 1.
n 1
a 0 n p  a1 n p 1  ...  a p
Untuk barisan Sn, dimana s n  , maka
b0 n q  b1 n q 1  ...  bq
• Barisan Sn akan konvergen ke 0 jika p<q
a
• Barisan Sn akan konvergen ke 0 jika p=q
b0
• Barisan Sn akan tidak konvergen ke 0 jika p>q
n
Jadi, dari contoh tadi maka konvergen ke 1 karena p=q=….(1)
n 1
n2
Dan tidak konvergen karena p>q=2>1
n 1
Contoh
 2 log n   0   log 2   log 3   log 4 
2 2 2
 2 log 8 
  konvergen ke 0, karena   ,  , ,  ,…,  
 n  1   2   3   4   8 
 0   1   log 3   2   2 log 210   10 
2
3
 , ,  ,   ,…,   ,….,  10  =  10  ini kecil sekali, sehingga
1   2   3   4  8   2  2 
konvergen ke 0.
Contoh
 n2 1 
  ini tidak konvergen, cara mencarinya
 n log n 
Cara 1
1
1 2
n2 1 n2 n  1 
lim : 2  lim
n   n log n n n   log n 0
n
Cara 2 dengan de’lopital
n2 1 n n 1
lim
n   n log n
 lim
1
 lim
n   log n  1
 lim  lim n  
n 1
n
log n  n * n

n n
n
lim 1
n
log n  n *
n

20
Latihan Soal

1. Jelaskan bagaimana masalah seharusnya di selesaikan

2. Dapatkah anda gambarkan komponen penyelesaian masalah, berikan contoh aktual.
3. Tuliskan pengertian konsep strategi algoritma dan analisa algoritma serta hubungan
diantaranya.
4. Dapatkah anda menuliskan struktur dasar algoritma, berikan contohnya
5. Jelaskan konsep mengenai algoritma, program, pemrograman.
6. Sebut dan jelaskan aspek-aspek suatu algoritma dan bagaimana pengukuran dilakukan.
7. Tuliskan konsep dasar suatu fungsi, deret dan barisan.
8. Apa peranan struktur data dalam analisa algoritma.

21
 BAB II
OVERVIEW ANALISA ALGORITMA
2.1. PENDAHULUAN
Dalam disain dan analisis algoritma, tujuan utamanya adalah bagaimana mendisain
algoritma yang “cepat”. Hal ini berarti kita harus merencanakan disain algoritma yang dapat
diselesaikan dengan alat bantu komputer yang mendekati suatu seni atau “art” . Jadi tidak saja
mendisain di perlukan pemikiran yang mendalam, namun juga kreatifitas yang tinggi dari
disainernya. Pemikiran untuk melakukan disain tidak saja cukup dilakukan secara sembrono
asal kreatif, namun juga harus berlandaskan atas teknik-teknik yang “well define”. Sehingga
pada bagian lain dari buku ini kita juga akan mempelajari teknik-teknik umum yang
scientifically. Dengan mempelajari teknik-teknik ini diharapkan kita dapat menyelesaikan
masalah disain algoritma dalam kehidupan nyata.
Pendekatan yang di pakai dalam strategi algoritma atau disain dan analisis algoritma
ini adalah pertama, pendekatan analitis, kedua, kita akan mambangun model matematika
untuk suatu komputer dan dalam model matematika tersebut kita membuat disain algoritma ,
ketiga, mempelajari property algoritma dalam model tersebut dan yang terakhir adalah
mengetahui alasan mengenai algoritma tersebut, dengan kata lain di perlukan bukti untuk
menunjukan waktu tempuh algoritma tersebut. Dalam bab ini akan di pelajari mengenai
framework dasar suatu algoritma, yang menjelaskan apa arti “cepat” suatu algoritma.
Dilanjutkan dengan mempelajari teknik mendisain algoritma yang “cepat”, yang secara
simultan juga mempelajari contoh-contoh masalah optimasi yang akan di sajikan pada bab
berikutnya. Juga akan di sajikan penyederhanaan atau pemodelan disain algoritma akan di
bangun di atas model komputer abstrak (mesin abstrak) yang menjadi simulator untuk
memahami kecepatan suatu algoritma.

2.2. PROBLEM DAN SOLUSI

Dalam studi algoritma, sebenarnya tidak lain kita di hadapkan pada munculnya suatu
masalah, yang akan di selesaikan secara komputasional dengan cara-cara tertentu. Bagian ini
akan memberikan overview mengenai masalah dan solusinya dalam suatu contoh sederhana.

22
Format penulisan disain dapat dilakukan secara bebas, namun demikian dalam buku ini akan
di berikan standar penulisan tersendiri sebagai berikut :
Tabel 1. Templete Spesifikasi Problem
PROBLEM Deskripsi masalah yang di hadapi
INPUT Domain dari masalah, harus valid untuk di berikan pada algoritma
OUTPUT Range dari masalah, keluaran yang di harapkan, spesifikasinya harus jelas
ALGORITMA Notasi yang menjelaskan penyelesaian masalah
Dengan membuat standar, di harapkan kita dapat membuat disain dengan lebih mudah untuk
di telusuri, contoh,
Tabel 2. Problem Faktorisasi
Diberikan suatu bilangan n, tentukan semua faktor dari bilangan tersebut. Misal 6
PROBLEM
adalah faktor dari 12, tetapi 6 bukan faktor dari 13, 1,3 dan 5 adalah faktor 15.
INPUT n adalah suatu integer positif, dimana n>0.
OUTPUT Daftar (barisan) bilangan yang merupakan faktor yang dapat membagi n hingga habis.
ALGORITMA a. Bagi n dengan bilangan terkecil yang > 0, misal x, yang dapat membagi n.
b. Ulangi proses (a) dengan mengincremen nilai x, hingga n=x.
Dalam notasi algoritma dituliskan sebagai berikut :
i1
input(n);
while (ni) do
if n mod i = 0 then
output(i)
inc(i)

Contoh lainnya
Tabel 3. Problem Faktorisasi Prima
Diberikan suatu bilangan n, tentukan semua faktor prima dari bilangan tersebut. Faktor
prima adalah 2, 3, 5, 7, 11, 13, atau 17, yaitu bilangan yang hanya dapat dibagi oleh
PROBLEM
dirinya sendiri dan 1, tidak berarti bahawa semua bilangan ganjil merupakan faktor
prima.
INPUT n adalah suatu integer positif, dimana n>2.
OUTPUT Daftar (barisan) bilangan yang merupakan faktor prima dari bilangan n.
ALGORITMA 9. Cari faktor prima terkecil dari suatu bilangan
10. Bagi bilangan n tersebut dengan faktor prima terkecil.
11. Ulangi proses 2 dengan n=hasil bagi terakhir hingga mencapai 1.
Sebagai latihan silahkan tuliskan notasi algoritma untuk masalah di atas.
Contoh masalah GCD,
Tabel 4. Problem GCD
PROBLEM Diberikan dua buah bilangan m dan n, tentukan GCD dari dua bilangan tersebut.
INPUT m dan n adalah suatu integer positif, dimana m<n.
OUTPUT GCD (Greates Common Divisor) atau integer terbesar yang membagi (habis) m dan n.
ALGORITMA 1. Faktorisasi prima sederhana
a) Faktorisasi m : menemukan bilangan prima pada m
23
 m1,m2,…mx, sedemikian sehingga m=m1Xm2…X mx.
b) Fakorisasai n : menemukan bilangan prima pada n
n1,n2,n3,…ny, sedemikian sehingga n=n1Xn2X…Xny
c) Identifikasi faktor-faktor umum (common factors) lalu kalikan dan
kembalikan hasilnya sebagai gcd
2. Euclid
a) Selama m tidak dapat membagi habis n maka lakukan
Tentukan r sebagai hasil bagi n dan m
Set nilai baru bagi n dengan m
Set nilai baru bagi m dengan r
b) Kembalikan m sebagai gcd
Selesaikan disain dari dua algoritma yang di berikan di atas dalam suatu notasi algoritma.

2.3. FRAMEWORK ANALISA ALGORITMA

Framework yang akan kita disain tidak hanya digunakan untuk memperbandingkan waktu
eksekusi dari suatu algoritma, tapi juga dapat di pakai untuk menentukan efisiensi memori
yang di pakai. Ide dasarnya adalah seperti pada penjelasan sebelumnya, yaitu menggunakan
model matematika untuk suatu komputer, lalu menganalisa eksekusi algoritma pada model
tersebut, sehingga kita akan mendapatkan waktu tempuh dari algoritma tersebut.

2.3.1. PEMODELAN SUATU KOMPUTER.

Pada model ini kita tidak akan mengeksekusi algoritma pada komputer tertentu yang
nyata, tetapi pada model matematika yang merepresentasikan suatu komputer dan
mengevaluasi waktu tempuhnya. Bagaimanakah model matematika itu di gunakan untuk
algoritma yang kita disain tersebut, sehingga kita akan mencoba menjawab beberapa
pertanyaan mendasar seperti :
a. Berapa waktu tempuh yang di perlukan pada model tersebut untuk setiap operasi
algoritma yang di jalankan.
b. Berapakah data yang seharusnya di inputkan pada algoritma tersebut.
c. Bagaimanakah model yang kita bangun tersebut berhubungan dengan komputer
sesungguhnya. Jika model yang kita bangun sangat berbeda, maka konklusi dari
model tersebut mungkin tidak berguna untuk komputer sesungguhnya.
Untuk menjawab pertanyaan di atas maka kita akan mulai dari beberapa definisi sebagai
berikut , definisi formal dan informal mengenai terminologi dasar, model matematika, strategi
analisia, beberapa contoh algoritma dan analisisnya, serta keterbatasan model.

24
2.3.2. DEFINISI FORMAL DAN INFORMAL TERMINOLOGI DASAR
Perhatikan beberapa contoh berikut ini mengenai terminologi Problem :
a. gcd 2 bilangan
input : 36,48
output : 12
b. Menemukan shortest path pada peta
input : nama kota di p. jawa
output : jarak 2 kota yang berhubungan dengan input
c. Menemukan kata dalam kamus
input : “evolusi”, oxford
output : kata input dalam kamus
d. Diberikan suatu x-ray, tentukan penyakitnya.
input : Gambar x-ray
output : ya/tidak berpenyakit

Jadi Problem adalah spesifikasi dari suatu nilai valid input dan apakah terdapat valid
output yang dapat di terima oleh setiap valid input tersebut. Instance input : suatu nilai x
adalah input instance untuk problem P, jika x adalah input valid sesuai dengan spesifikasi.
Dari contoh di atas maka bilangan 36,48 dan 12 merupakan input dan output instance dari
problem gcd, begitu juga contoh lainnya untuk masing-masing problem.
Ukuran Input Instance (size of an input instance) secara formal dikatakan sebagai,
sejumlah sedikit yang di perlukan untuk merepresentasikan suatu input instance. Sedangkan
secara informal (lebih berguna), dikatakan sebagai tiap parameter yang tumbuh secara cepat
dengan ukuran formalnya. Dengan demikian terminologi Algoritma adalah suatu abstraksi
prosedur komputer yang memerlukan beberapa atau banyak nilai input dan menghasilkan
beberapa atau banyak nilai sebagai output.
Dikatakan abstrak, karena algoritma dapat di ekspresikan dengan berbagai cara, misal
gambar, psuedo code, rumus matematika, program, dan sebagainya. Dan yang terakhir adalah
Program yaitu merupakan ekspresi dari suatu algoritma dengan menggunakan suatu bahasa
yang di mengerti komputer.

2.3.3. MODEL MATEMATIKA PADA KOMPUTER

Model yang akan kita pakai dalam buku ini adalah suatu RAM, yaitu Random Access Machine,
yang merupakan penyederhanaan dari suatu model komputer yang pada dasarnya terdiri dari dua

25
bagian utama, yaitu Prosesor yang mengeksekusi program dan Memori, yaitu koleksi suatu lokasi,
mirip array.

0 m-1
Gambar 7. Layout Memory RAM

Sehingga dari gambar 7 diatas maka memori terdiri dari m lokasi, yang tiap lokasinya
mempunyai alamat (address). Untuk mengacu alamat maka kita akan mengakses nilai dari
alamat tersebut. Mulai dari 0 hingga m-1. Bagaimana kita akan mendisian dalam model RAM
ini ? Karena model RAM mengandung alamat yang di notasikan dengan angka, maka kita
akan menentukan suatu variabel untuk mengaksesnya, sehingga kita akan, memberi nama
pada variable di ijinkan. Juga tipe data seperti array, struktur dan primitive juga di ijinkan,
selain itu struktur data seperti list, tree juga dapat di oleh dalam RAM. Instruction Set of
Processor pada RAM di arsitektur ini adalah, setiap instruksi akan di kerjakan dalam satu
langkah. Ada 3 kelompok instruksi pada model ini yaitu :

a. Operasi Aritmatik dan Logic

Contoh : A=B+C adalah satu instruksi, karena RAM akan membaca sebagai berikut,
ambil dua operan (B dan C) yang di simpan dalam suatu lokasi lalu tambahkan dan
simpan kembali (di A).
b. Jump dan Kondisi jump , operasi ini juga akan di baca sebagai satu instruksi.
Contoh : goto atau If A>B then goto
c. Instruksi Pointer/Array (operasi array satu dimensi), juga di lakukan dalam satu
instruksi. Array dan pointer di perlakukan sama dalam eksekusinya.
Contoh : B=*C , *C = B, A[i] = B, B = X[i].
Dalam tipe data array, misal A[100], maka di memori di sediakan lokasi sebanyak 100,
begitu juga terminology struktur yang terdiri dari 3 field, misal,
type struct AA{
int x, int y, int z;
}
maka struktur AA di simpan dalam 3 alamat lokasi. Contoh lain dari algoritma yang lebih
kompleks instruksinya adalah sebagai berikut,
26
A=B+C*D-F
Berapa instruksi yang di jalankan prosesor ?, kita akan pecah ekspresi tersebut yang di
dasarkan atas banyak operasi (+,* dan -), jadi pada instruksi di atas terdapat 3 langkah yang
akan di kerjakan oleh prosesor. Sekarang perhatikan contoh lain di bawah ini,
A[i] =B[i]+C[i], maka fetch prosesor adalah
X =B[i], direct access ke memori 1 langkah
Y =C[i], direct access ke memori 1 langkah
Z =x+y, direct access ke memori 1 langkah
A[i] =Z, direct access ke memori 1 langkah
Sehingga eksekusi untuk ekspresi di atas ada 4 langkah. Untuk array multidimensi, misalkan
Array A mempunyai 2 baris dan 4 kolom, seperti gambar di bawah ini,

a b c D
e f g h

Gambar 8. Array 2 dimensi A

Dalam RAM, akan di simpan seperti array satu dimensi sebagai berikut, A 1 .
a b c d e f g h
Gambar 9. Representasi Array 2 dimensi A1 dalam RAM
Sehingga untuk mengakses A[i,j] maka ekuivalen dengan A1[i*m+j], dimana m adalah
jumlah kolom dalam A, yaitu 4. Jadi missal C=A[i,j] di baca sebagai C=A 1[(i-1)*m+j],
sehingga dari operatornya kita tahu ada 3 langkah ditambah akses secara langung ke memori 1
langkah total ada 4 langkah. Bagaimana dengan suatu operasi yang melibatkan struktur dasar
algoritma, missal loop atau perulangan, dalam contoh berikut kita dapat menghitung langkah
array sebagai berikut,
for i=1 to n do
C[i]=A[i]+B[i];
endfor

ekuivalensi statemen di atas adalah

27
 1. i=1
2. if i>n then goto 9
3. X=A[i]
4. Y=B[i]
5. Z=X+Y
6. C[i]=Z
7. I=i+1
8. Goto 2
9.

Gambar 10. Ekuivalensi fragmen loop dalam RAM

Sehingga analisa algoritma dari fragmen di atas adalah,

1 langkah

Akan di 1. i=1
eksekusi
2. if i>n then goto 9
sekali tiap
iterasi. Jika 3. X=A[i] n langkah iterasi dalam body
iterasinya n,
4. Y=B[i]
maka instruksi
ini di eksekusi 5. Z=X+Y
n kali di 6. C[i]=Z n iterasi kali 2 langkah = 2n
tambah
eksekusi 7. I=i+1
kondisi 1 kali 8. Goto 2
9.

Gambar 11. Analisa Algoritma dalam RAM

Total waktu tempuh untuk fragmen di atas adalah b*n+2n+(n+1)+1, b adalah body of loop
dalam iterasi sebanyak n, sehingga menjadi 2+n(b+3), dimana b terdiri dari 4 langkah, maka
akan di dapatkan 2+7n atau 7n+2. Dalam hal pemanggilan fungsi, untuk menghitung langkah
pada pemanggilan fungsi dalam algoritma adalah Waktu = Jumlah Argumen Fungsi.
Dalam hal ini kita akan mengacu pada sintak gaya bahasa c, artinya tipa data array dan
structure di katagorikan dalam pass by references dan variable primitive sebagai pass by
value. Dengan demikian dapat di simpulkan bahwa,

28
a) Model matematika harus dapat direlasikan dengan kenyataan
b) Perlu Analisa Algoritma untuk pemodelan dan disain yang bagus
c) Relevansi analisis kita untuk komputer sebenarnya

2.3.4. PERBANDINGAN RAM DENGAN KOMPUTER ATAU KOMPILER

NYATA
Perbandingan dapat dilakukan pada computer nyata dengan RAM, bahkan pada compiler
juga diberlakukan hal yang sama karena compiler juga dapat membedakan dengan RAM saat
eksekusi di memori. Dalam perbandingan tersebut kita akan melihat bagian mana RAM yang
berperan dalm eksekusi algoritma.
Pada komputer nyata, system komputer lebih komleks di banding RAM yang hanya terdiri
dari satu prosesor dan satu memori dengan 3 kelompok instruksi yang di milikinya. Struktur
komputer nyata memiliki banyak macam memori (main memory, cache, register). Terdapat
pipeline pada disain arsitektur komputer nyata, yaitu instruksi yang berbeda dapat di eksekusi
secara simultan dalam beberapa langkah yang berbeda. Komputer juga ada yang bersifat
superscalar, mirip dengan pipeline, dimana 1 – 4 instruksi di kerjakan secara simultan.
Pada komputer nyata instruksi perpindahan data dapat di kerjakan dengan berbagai cara,
instruksi pengkutipan memori-register, instruksi aritmatik hanya di dalam register.Pada contoh
tabel di bawah ini menunjuka perbedaan yang nyata dari RAM dengan computer nyata.
Tabel 5. Perbedaan RAM dengan Komputer Nyata
RAM KOMPUTER NYATA
Instruksi Langkah Instruksi Langkah
A=B+C 1 langkah load b ke r1 1
load c ke r2 1
add r2,r1 ke r3 1
store r3 ke a (main memori) 1
Total = 4 langkah
Juga dalam hal komputasi pada RAM dengan komputasi pada kompiler (intelegence compiler)
dapat di contohkan sebagai berikut, misal fragmen programnya adalah
1. if x[i]=1 then do ….
2. if x[i]=2 then do ….
Translasi sederhana dari contoh fragmen diatas adalah, kita harus mengekstrak nilai dari x[i],
karena kita tidak dapat melakukan operasi logika secara langsung pada komponen array,
sehingga untuk mentranslasikannya adalah dengan cara sebagai berikut :

29
 1. Dari instruksi yang pertama, buat variable sementara, temp untuk menampung nilai
array x[i],temp= x[i]
Untuk instruksi yang kedua tidak perlu di lakukan, misal temp1=X[i], sebab, dalam RAM ,
tampungan sudah di lakukan pada instruksi sebelumya, inilah yang di sebut sebagai
intelegence compiler. Sedangkan pada compiler nyata hal tersebut tidak dilakukan, karena
setiap instruksi harus di fetch dari memori untuk di lakukan cycle execution oleh prosesor.
Alasan lainnya kenapa di RAM tidak dilakukan tampungan pada instruksi ke dua, karena pada
kedua instruksi tersebut nilai x[i] tidak berubah, jadi oleh intelegence compiler dianggap satu
langkah saja.

2.4. STRATEGI UMUM ANALISA ALGORITMA

Dalam menganalisa algoritma kita memerlukan suatu strategi, dimana strategi tersebut,
didasarkan pada model matematika yang kita bangun. Model matematika yang paling
sederhana yang dapat kita pakai sebagai model untuk menerapkan strategi analisa algoritma
adalah dengan memakai suatu fungsi T(n). Fungsi TA(n) adalah waktu tempuh maximum
algoritma, misal A, yang di jalankan untuk menyelesaikan masalah dalam RAM untuk
setiap input instance berukuran n. Sehingga, untuk input instance n yang berukuran sama
dan di terapkan dalam algoritma yang berbeda untuk menyelesaikan masalah yang sama,
dapat mempunyai waktu tempuh yang berbeda pula, artinya T(n) dapat menghasilkan nilai
yang berbeda. Dengan demikian dari perbedaan waktu tempuh (mungkin berbentuk suatu
persamaan) akan di ambil yang mempunyai nilai terbesarnya. Untuk itu kita akan menguji
untuk menganalisa pada sejumlah ukuran data, misal T(1),T(2),T(3),….,T(n). Sehingga fungsi
T(n) akan dapat mengukur kehandalan dari algoritma A tersebut. Dari definisi diatas kita
dapat mengetahui propertinya sebagai berikut :
a) Secara konservatif, kita akan mencari hasil akhir dari waktu tempuh yang bersifat
terburuk atau worst case time, atau waktu maksimum yang dapat diperoleh saat
algoritma menyelesaikan masalah dengan input instance sebesar n. Karena dengan
strategi ini kita akan dapat melihat keunggulan algoritma lainnya yang mempunyai
waktu tempuh lebih sedikit dari yang ada, dan untuk hal tersebutlah kita melakukan
analisa terhadap algoritma yang mempunyai waktu tempuh terburuk, dan bukan pada
waktu tempuh terbaik atau rata-rata. Pada kasus terburuk maka kompleksitas algoritma
30
 dianggap berbanding terbalik, yaitu sederhana, dan untuk algoritma yang mempunyai
kompleksitas tinggi biasanya waktu tempuhnya lebih cepat.
b) Bentuk fungsi T(n) sangat penting untuk dapat membandingkan algoritma yang akan
di aplikasikan pada komputer nyata dengan RAM, baik waktu tempuh maupun
kompleksitasnya. Artinya apakah hasi fungsi yang terbentuk adalah Linear, quadratik,
kubik, logaritmik atau yang lainnya. Sehingga fungsi T(n) merupakan fungsi yang
independen terhadap komputer yang akan di pakai untuk mengukur algoritma tersebut
dalam kehidupan nyata.
c) Kita dapat mengestimasikan algoritma tersebut pada suatu fungsi yang apakah
termasuk lower bound, upper bound pada T(n).
d) Kita akan dapat menguji algoritma pada n berukuran besar, semakin besar ukuran n
yang dapat kita ujikan, semakin baik algoritma tersebut, karena dapat menangani input
instance besar dengan waktu yang konstan.

2.5. CONTOH PROBLEM

a) Perkalian Matrik
Tabel 5. Algoritma Perkalian Matrik
PROBLEM Perkalian Matrik
INPUT A, B adalah matrik nXn
C adalah matrik nXn, dimana C=A.B, sedemikian sehingga
OUTPUT C ij  A
k
ik  B kj
ALGORITMA Straight Foward
Bagaimana mendisain algoritma untuk permasalahan di atas ? Sebenarnya banyak algoritma
untuk menyelesaikannya, tapi pada bagian ini akan di jelaskan yang paling sederhana saja.
Algoritma perkalian matrik straight forward, seperti tampak pada gambar 12 sebagai berikut :

for i=1 to n do
for j=1 to n do
C[i,j]=0
for k=1 to n do
C[i,j]=C[i,j]+A[i,k]*A[k,j]
endfor
endfor
endfor

Gambar 12. Fragmen Perkalian Matrik

31
Analisa algoritma dari fragmen di atas adalah,
Ingat property dari perhitungan dan analisa langkah atau instruksi pada loop , yaitu
a) Waktu tempuh pada loop for :
body : b langkah
iterasi : n
Waktu tempuh : 2+n(b+3) langkah.
b) Waktu tempuh akses pada elemen array 2 dimensi adalah 4 langkah
c) Analisa Algoritma, perhatikan instruksi terdalam dalam loop
4*4 akses array
for i=1 to n Dan 2 operator
for j=1 to n 4*4+2=18
C[i,j]=0 1
for k=1 to n
C[i,j]=C[i,j]+A[i,k]*A[k,j]
endfor =2+n(b+3)
endfor =2+n(18+3)
endfor =21n+2 2

2+n(b+3) 4 Terdapat akses array, 4 dan

2+n((21n+7)+3) 1 assignment, sehingga b
21n2+10n+2 menjadi (21n+2)+4+1 yaitu
2+n(b+3) (21n+7)
5 3
2+n((21n2+10n+2)+3)
2+n(21n2+10n+6)
21n3+10n2+6n+2

Gambar 13. Analisa Agoritma Perkalian Matrik

Hal penting yang harus di perhatikan adalah, pangkat terbesar dari fungsi diatas yang menjadi
focus dari analisa yaitu n3 (kubik), yang merupakan worst case dari algoritma ini. Dari sisi
arsitektur computer dan compiler nyata, maka hasil eksekusi di atas sangat berbeda, karena
beberapa hal yang sudah di bahas sebelumnya (mungkin lebih cepat, karena menggunakan
banyak memori dan tata cara fetch instruksi yang di oleah kompiler berbeda). Namun
demikian fokus utamanya adalah pendekatan berdasarkan model matematika ini cenderung
mencari waktu eksekusi terlama yang dapat di lakukan dan bila pada kenyataannya pada
aplikasi nyata akan lebih cepat, itu tergantung dari arsitektur nyata computer yang
memakainya.
Kesimpulan analisa dari algoritma di atas adalah dia berjalan pada waktu tempuh kubik (n3),
sehingga dari perhitungan tadi kita dapat menyimpulkan bahwa bentuk akhir dari fungsi T(n)
32
adalah An3+Bn2+Cn+D, dan kita tidak merisaukan berapa nilai A,B,C atau D, karena kita tahu
bahwa fungsi tersebut berada pada order kubik.
b) Nilai Median
Tabel 7. Problem Finding Mendian
PROBLEM Menentukan Nilai Medium
INPUT N bilangan, x1,x2,x3,…xn
OUTPUT Nilai Median dari sederetan N bilangan
ALGORITMA Straight Foward

Nilai median adalah nilai tengah dari sekumpulan data dalam range tertentu. Algoritma
untuk menemukannya ada banyak, namun kita akan coba analisa dengan menggunakan cara
straight forward. Disain algoritmanya adalah sebagai berikut untuk menyelesaikan masalah
pencarian data medium dari sekumpulan data hingga bilangan n.

median(x)
1.n=panjang(x)
2.for i=1 to n do
3. min=0
4. max=0
5. for j=1 to n
6. if x[i]>x[j] then min=min+1
7. if x[i]<x[j] then max=max+1
8. endfor
n max
9. if min< and then exit
2 n
2
10.endfor

Gambar 14. Algoritma Finding Mendian

Analisa algoritma pada prolem median di atas adalah sebagai berikut, kita akan melihat inner
loop, lalu keluar ke atas hingga lapisan terluar.

33
 C langkah
1. median(x)
2. n=panjang(x)
3. for i=1 to n
4. min=0 n langkah
5. max=0 linear n,
6. for j=1 to n An+B
7. if x[i]>x[j] then min=min+1
8. if x[i]<x[j] then max=max+1
9. endfor
n max n langkah dalam
10. if min< and then exit linear n,
2 n maka dia berada
2 dalam quadratic n.
11. endfor dengan catatan
sebelum keluar dari
loop karena exit

n langkah
Jadi secara keseluruhan waktu
tempuhnya berada dalam quadratic,
Ax2+Bx+C

Gambar 15. Analisa algoritma Finding Median

Tugas anda adalah membuktikan bahwa algoritma tersebut benar berada dalam order
quadratic dengan menghitung setiap langkahnya hingga terbentuk fungsi T(n)=Ax2+Bx+C.

34
Latihan Soal
1. Tuliskan tujuan membuat disain algoritma.
2. Apa arti kata “cepat” dalam terminology analisa algoritma
3. Disain dan analisa algoritma termasuk seni atau pengetahuan, bagaimana hubungan
keduanya.
4. Tulisakan template problem dan solusi untuk disain algoritma dengan suatu contoh
kehidupan sehari-hari
5. Kenapa disain algoritma perlu di modelkan, serta model apa yang tepat untuknya.
6. Jelaskan pengertian RAM (Random Access Machine) dan apa yang dapat di lakukannya.
7. Jelaskan perbedaan antara computer nyata dan RAM.
8. Jelaskan dengan istilah waktu tempuh maximum algoritma.
9. Hitunglah waktu tempuh pada fragmen berikut ini
for i=n to 1 do
if n mod 2 = 0 then
x=x+1;
n=n/2
else
x=x+1
n=3*n+1
if n=1 then break;

10. Apa arti persamaan T(n)= anxn+…+a1x+a0 dalam order suatu fungsi.

35
 BAB III
NOTASI ASIMTOTIK

3.1. PENDAHULUAN
Suatu masalah mungkin memiliki solusi algoritmik yang banyak. Dalam rangka untuk
memilih algoritma terbaik untuk suatu tugas tertentu, kita harus dapat menilai berapa lama
solusi tertentu akan diperlukan saat dijalankan. Atau, lebih akurat, Anda harus dapat menilai
berapa lama dua solusi yang diperlukan saat dijalankan, dan memilih diantara dua algoritma
tersebut. Kita tidak perlu tahu berapa menit dan detik waktu yang di tempuh oleh algoritma
tersebutl, tapi kita perlu beberapa cara untuk membandingkan algoritma terhadap satu sama
lain.
Kompleksitas asimtotik adalah cara mengungkapkan komponen utama cost dari
algoritma, dengan menggunakan unit ideal kerja komputasi. Perhatikan, misalnya, algoritma
untuk menyortir setumpuk kartu, yang hasilnya dengan berulang kali mencari melalui dek
untuk kartu terendah. Kompleksitas asimtotik dari algoritma ini adalah kuadrat dari jumlah
kartu di dek. Perilaku kuadrat adalah istilah utama dalam formula kompleksitas, sehingga
dapat dikatakan, misalnya, jika kita punya dua kali ukuran dek kartu, maka pekerjaan
pengurutannya adalah empat kali lipatnya. Sehingga jika kita memiliki 52 kartu, maka kita
akan melakukan scanning selanjutnya ke kartu 51 dan seterusnya, dan jika di formulasikan
menjadi 52+51+…+2. Jika di berikan N kartu maka formulanya adalah 2+…+N yang sama
dengan ((N)*(N+1)/2)−1=((N2 +N)/2)−1=(1/2)N2+(1/2)N−1, dari formulasi tersebut kita
tahu bahwa N2 sangat mendominasi ekspresi tersebut dan inilah yang di sebut sebagai cost
perbandingan dari suatu algoritma. Sehingga secara asimptotik di katakana bahwa pada limit
N, cenderung kearah infinity, dan mendekati fungsi kuadratik ½ N2, dan dikatakn sebagai
O(N2).
Misalkan f(n) adalah cost, dalam kasus terburuk, dari satu algoritma, yang dinyatakan
sebagai fungsi dari ukuran masukan n, dan g(n) merupakan fungsi cost untuk algoritma yang
lain. Misalnya, untuk algoritma pengurutan, f(10) dan g(10) akan menjadi jumlah maksimum
langkah yang di ambil oleh algoritma dari list sejumlah 10 item. Jika, untuk semua nilai n≥ 0 ,
f(n) adalah kurang dari atau sama dengan g(n), maka kompleksitas algoritma dengan fungsi f

36
adalah sangat cepat. Namun, secara umum, kita konsern pada cost komputasi yaitu untuk
kasus dengan masukan yang besar, sehingga perbandingan dari f(n) dan g(n) untuk nilai kecil
n kurang signifikan dibandingkan dengan perbandingan dari f(n) dan g(n), untuk n lebih besar
pada threshold tertentu. Ini dikatakan sebagai batas performa algoritma, sehingga batas dari
contoh pengurutan di atas berada pada kuadratik. Pengelompokan fungsi inilah yang akan kita
pelajari pada bab berikut untuk membedakan waktu tempuh suatu algoritma yang berada pada
batasan tertentu. Notasi yang akan di pelajari adalah Notasi O (Big Oh), Omega dan Theta.

3.2. DEFINISI
Karena tujuan kuliah disain dan analisa algoritma atau strategi algoritma ini adalah :
a) mendisain algoritma yang cepat
b) menganalisa waktu tempuh yang di lakukan RAM
c) Karena hasil analisa dengan RAM tidak dapat di aplikasikan pada komputer lain, maka
kita akan mencari cara, supaya keberlakuan hasil analisis dapat di pakai oleh semua
komputer.
Contoh berikut adalah, jika pada RAM menghasilkan waktu tempuh (1) 10n3+5n2+7, kita
tahu bahwa T(n) tersebut berada pada area kubik, dan jika komputer lain menghasilkan (2)
2n3+3n+79, hal ini seharusnya dapat di nyatakan juga berada dalam ranah kubik. Dengan
demikian (1) dan (2) berada pada kelas yang sama. Oleh karena itu di perlukan suatu notasi
untuk menyatakan waktu tempuh, sedemikian rupa sehingga dapat berlaku di semua
komputer. Maka kita perlu menentukan pengkelasan fungsi (classes of function)
3.2.1. CLASSES OF FUNCTION
Beberapa terminologi dasar dalam memahami notasi asymptotic, merupakan
pengetahuan yang harus di mengerti terlebih dahulu. Semua fungsi yang menjadi output dari
analisa algoritma akan di kelompokan dalam suatu kelas untuk di berikan notasinya.
Asymptotic Notation merupakan notasi formal untuk mengungkapkan mengani suatu fungsi
dan mengklasifikasikannya, Asymptotic Analysis adalah menganalisis dan mengklasifikasikan
suatu fungsi ke dalam notasi asimptotik dan untuk mengklasifikasikan notasi kita perlu fitur-
fitur untuk melakukannya, ada 2 fitur utama yang perlu di jelaskan di sini yaitu :
a) Bagaimana meletakan fungsi yang berbeda ke dalam kelas yang sama, misal
10n3+5n2+17 dan 2n3+3n+79 seharusnya berada dalam satu kelas. Sehingga pengali
konstan (constant multiplier) harus diabaikan dalam kedua fungsi diatas.

37
 10n3+5n2+17 2n3+3n+79

DIABAIKAN

Gambar 16. Pengabaian Konstanta

b) Notasi pada Class juga harus memperhatikan adanya kencenderungan nilai n ke arah tak
hingga (n ), sehingga kita uga harus memperhatikan ukuran dan prilaku dari input
instance n.
Notasi asimtotik menyatakan batas fungsi-fungsi tersebut apabila nilai input instance n
semakin besar, jadi Notasi asimtotik merupakan himpunan fungsi yang dibatasi oleh suatu
fungsi n  N yang cukup besar.
3.2.2. Notasi “Big Oh” ATAU “O”
Definisi 1
Merupakan batas atas fungsi (upper bound) atau order waktu proses, g: N R+ adalah
suatu fungsi O(g(n)) merupakan kumpulan fungsi-fungsi N R+ yang mempunyai batas atas
g(n) untuk n yang cukup besar. Dinyatakan secara matematis dengan,
O(g(n))={f(n)|(cR+)(n0N) f(n)≤c.g(n), N ≥ n0)}
Atau secara definisi di katakan sebagai, f(n) merupakan big oh dari g(n) yang di tulis dengan
f(n)=O(g(n)) jika terdapat integer n0 dan konstan c>0 sedemikian rupa sehingga n≥n0,
f(n)≤c.g(n). Jika f(n)=n+12, seperti di tunjukan pada gambar 17, jelas menunjukan fungsi
non-negatif untuk semua integer n≥0. Kita akan menunjukan bahwa f(n)=O(n2) sesuai definisi
di atas, maka kita akan cari integer n0 dan konstan c>0 sedemikian rupa sehingga untuk semua
integer n≥n0 , f(n)≤c.n2. Misal c=1,
f(n)≤c.n2  4n+32≤n2
 0≤n2-4n-32
 0≤(n-8)(n+4)
Karena (n+8)>0 untuk semua nilai n≥0, kita dapat simpulkan (n0-8)≥0, sehingga n0=8.Jadi
kita memperoleh c=1 dan n0=8, f(n) ≤c.n2 untuk semua integer n≥n0. Dengan demikian

38
f(n)=O(n2), seperti di tunjukan dalan fungsi f(n)=n2 adalah lebih besar dari fungsi f(n)=
4n+32 ke kanan dari n=8. Contoh lain jika di ekspresikan dengan limit, misakan :
lim f ( n )
 c , untuk 0c
n   g( n)
Contoh 1.
lim n 3 lim
 n    n 3  O(n 2 )
nn 2
n
Contoh 2.
lim n 2  n lim 1  1
  1  n 2  n  O(n 2 )
n n 2
n 1

y=f(n)

f(n)=4n2 f(n)=2n2

400 f(n)=n2

f(n)=4n+32
200

0 5 10 15 20 25
n
Gambar 17. Fungsi f(n)=4n+32 = O(n2)
Contoh lain,
• 1000 n2  O(n3) karena
f(n) ≤ c.n3 , untuk c=1
1000.n2 ≤ n3
0 ≤ n3-1000.n2
untuk n ≥ 1000, c=1, maka n0=1000
Sehingga memenuhi f(n) ≤c.g(n) untuk semua integer n≥n0

39
• 1000 n2  O(n2), Carilah c dan n
1000 n2  O(n2)
1000 n2 ≤ c n2 , untuk c = 1000, maka
1000 n2 ≤ 1000 n2 , n ≥ 1, n0=1
• Apakah 5n + 10  O (n2) ?
Ya, karena 5n + 10 < 5n2 + 10n2 = 15n2 untuk n > 1
Jadi untuk c = 15, n0 = 1 |5n + 10| < c . |n2|
Jika L = 0, maka f(n)  O(g(n)) dan g(n) O(f(n))
Jika L  0, maka f(n)  O (g(n)) dan g(n) O (f(n))
Jika L =  , maka f(n)  O (g(n)) dan g(n) O (f(n))
• f(n) = 3n2+5n+10
g(n)=n2 merupakan order atau batas atas untuk f(n)
g(n)  f(n)
misal : 3g(n)=3n2 3n2+5n+10,
Bagaimana dengan (3+1)g(n)=4n2 ….…3n2+5n+10  4 n2
dengan n10 , n0 =10 dan 3n2+5n+10  4n2, c=4
Jadi 3n2+5n+10  O(n2), karena untuk n 10 , 3n2+5n+10  4n2
Jadi untuk menyelesaikan ketidaksamaan di atas kita juga dapat menggunakan limit atau
memanfaatkan fungsi limit seperti yang sudah di contohkan di atas, sebagai berikut :
Teorema 1,
f (n) c     0  f (n)  O( g (n))
lim 
n   g (n)   f (n)  O( g (n))
Penyelesaiannya, 3n 2  5n  10 5 10
lim 2
3  2  3 0  0
n  n n n
0c

3.2.3. TEOREMA DALAM NOTASI BIG OH ATAU “O”

Teorema 2: Polinomial

Jika a0,a1,…,an adalah bilangan riil dengan an0 maka f(x)=anxn+…+a1x+a0 adalah O(xn).

40
Jika diketahui order deret 1+2+3+…+n , maka dapat di tuliskan sebagai 1+2+3+…+n = ½
n2 + ½ n, sehingga ordernya adalah O(n2).
Teorema 3: Logaritma

Jika b adalah bilangan riil > 1 maka blog x adalah O(xn) untuk semua bilangan bulat n1 xn
adalah O(bx) untuk semua ilangan bulat n0 x blog x adalah O(x2)  x  b.
Teorema 4: Hirarki

Setiap fungsi merupakan big oh dari fungsi kanannya, 1,2log(n),…., , , , n, n(2log (n)),n ,
n2,n3,…,2n,n!,nn.
Teorema 5 : Lainnya

Jika f(n) =O(g(n)) dan c adalah konstanta maka c.f(n)=O(g(n))

Jika f(n) =O(g(n)) dan h(n)= O(g(n)) maka h(n)+f(n)=O(g(n))
Jika f(n) =O(a(n)) dan g(n)= O(b(n)) maka f(n) g(n)=O(a(n) b(n))
Jika a(n) =O(b(n)) dan b(n)= O(c(n)) maka a(n)=O(c(n))
Jika f(n) =O(a(n)) dan g(n)= O(b(n)) maka f(n)+g(n)=O(max {|a(n)|,|b(n)|})

Perhatikan contoh berikut, nyatakan fungsi di bawah ini dalam notasi O dari :
a. n+n(2 log n)
n 3 sin n( 2 log n)
b.
1 2
n( log n)  3n  15
c. 2

Jawab :
a. N=O(n);n(n(2 log n)), sehingga O(n(n(2 log n)))=O(max {n, n(2 log n)}), karena
letak O(n) menurut teorema hirarki, lebih kiri dari n(2 log n), maka max {n, n(2
log n)}= n(2 log n), sehingga n+n(2 log n) adalah O(n(2 log n))
b. n 3 sin n( 2 log n) , karena sin n1, sehingga n 3 sin n adalah O( n 3 ),
disamping 2 log n adalah O( n ), maka n 3 sin n( 2 log n) adalah
O( n 3 , n ) =O(n2)
1 2
n( log n)  3n  15
2
41
 c. adalah O(n(2 log n)) , sebab 3n adalah O(n) dan 15
1 2 2
adalah O(1), jadi n( log n)  3n  15 adalah O(max{ n( log n), n,1 }),
2
karena n(2 log n) terletak paling kanan (teorema hirarki), maka max{ n(2 log n),
1 2
n,1 }= n(2 log n), sehingga 2
n( log n)  3n  15 adalah O(n( log n)).
2
3.2.4. NOTASI OMEGA (Ω)
Definisi 2
Berdasarkan fungsi non-negatif f(n) untuk semua integer n>=0, kita katakanan bahwa f(n)
adalah Omega g(n), yang ditulis dengan f(n) = Ω(g(n)), jika terdapat suatu integer n0 dan
konstan c>0 sedemikian rupa sehingga untuk semua integer n>=n0, f(n)>=c.g(n).
Definisi ini hampir mirip dengan Notasi O, dengan perbedaan dalam perbandingan nya.
Jika dalam O, f(n)≤g(n), maka dalam omega, f(n)≥g(n). Sehingga dia merupakan kebalikan
dari big Oh, (Order) Ω(g(n))=f(n) merupakan batas bawah fungsi-fungsi f(n) ,di nyatakan
dalam kalimat matematis sebagai :

Ω (g(n)) = {f(n)/(c  R+ ) ( n0  N)  f(n) ≥ c . g (n), N ≥ n0).

Dan dalam limit di berikan

lim
f ( n)
n   g ( n)
 0  f ( n )O ( g ( n ))
c  
 
  f ( n ) ( g ( n ))

Contoh :
3n2+5n+10Ω(nn), tetapi 3n2+5n+10Ω(n2 log n), karena
3n 2  5n  10 3 5 10
lim  lim    000  0
n   n 2 log n n   log n n log n n 2 log n
Perhatika fungsi berikut, f(x)=5n2-64n+256 seperti di tunjukan pada Gambar 18 di
bawah ini. Jelas sekali bahwa f(n) merupakan fungsi non-negatif untuk semua integer n≥0,
kita akan menunjukan bahwa f(n)=Ω(n2). Berdasarkan definisi 2, di atas, dalam rangka untuk
mendapatkan integer n0 dan konstam c>0 sedemikian rupa sehingga memenuhi n≥n0, f(n) ≥
c.n2. Seperti dalam big oh, kita akan berikan suatu nilai ke konstan selama terdapat suatu
integer, misal c=1, maka

42
f(n)≥ c.n2 5n2-64n+256>n2

4n2-64n+256>=0

4(n-8)2 >= 0

2
Karena (n-8) >0 untuk semua nilai n≥0 maka kita simpulkan bahwa n0=0, jadi kita
temukan fakta bahwa untuk c=1 dan n0=0, f(n)≥c.n2 untuk seluruh integer n≥n0.

Dengan demikian f(n)=Ω(n2), dan gambar 18 dengan jelas memeberikan gambaran

fungsi f(n)=n2 yang kurang dari f(n)=5n-64n+256 untuk semua nilai n≥0, tentu saja terdapat
banyak nilai untuk c dan n0, misal c=2 dan n0=16, maka diplot menjadi seperti gambar 18.
y=f(n)
1500

f(n)=5n2-64n+256

1000
f(n)=2n2

500
f(n)=n2

0 5 10 15 20 25
n
Gambar 18. Fungsi f(n)=4n-64n+288 = Ω(n2)
3.2.5. NOTASI THETA (Θ)
Definisi 3
Untuk semua fungsi non-negatif, f(n) dan g(n), f(n) adalah theta dari g(n) jika dan hanya
jika f(n) = O(g(n)) dan f(n) = Ω(g(n)). Hal ini di notasikan dengan "f(n) = Θ(g(n))".

 f adalah fungsi non - negative sedemikian rupa sehingga  konstant 

 
( g )   f c1 , c 2 , n 0 sedemikian rupa sehingga c1 .g(n)  f(n)  c 2 .g(n), untuk 
 nn 
 0 

43
Pada dasarnya dapat di katakana bahwa fungsi , f(n) merupakan batas dari atas dan bawah dari
fungsi yang sama yaitu, g(n). Untuk lebih jelasnya perhatikan grambar 19 berikut ini

(g)
c2.g(n)

c1.g(n)

f(n)

n0
n

Gambar 19
Teorema 6
 0  f (n)  O( g (n)), f (n)  ( g (n))
f ( n)  
lim
n  g ( n)
c    f (n)  O( g (n))  ( g (n))  ( g (n))
   f (n)  O( g (n)), f (n)  ( g (n))

Sehingga,
f(n)  (g(n)) bila dan hanya bila f(n)  O (g(n)  Ω (g(n)))
f(n) mempunyai order yang sama dengan g(n)
f(n)  (g(n)) bila dan hanya bila g(n)  (f(n)) dan f(n) berupa fungsi non rekursif
Notasi Asimtotik digunakan untuk menentukan kompleksitas suatu algoritma dengan melihat
waktu tempuh algoritma. Waktu tempuh algoritma merupakan fungsi : N → R+, Jadi
O(g(n))Ω(g(n)) Θ(g(n)) maka, f(n) Θ(g(n)) BILA DAN HANYA BILA (g(n))  Θ(g(n))
Contoh
 f1(n)=10n3+5n2+17  (n3)

44
 f2(n)=2n3+3n+79  (n3)
Sebenarnya dari definisi diatas kita hanya perlu mencari konstan c1 dan c2 serta n0 yang
memenuhi definisi tersebut, maka dari 2 pernyataan tersebut di atas kita dapat buktikan
sebagai berikut :

10n3f1(n)(10+5+17)n3=32n3, sehingga c1=10 dan c2= 32, maka akan di dapat sebagai
berikut , c1.n3 f1(n)  c2.n, untuk semua n  n0=1. Jelas terlihat 10n3f1(n) karena definisi
teori, untuk mengambil konstan pertama dari polinomial terbesar dari f1(n), dan untuk
mendapatkan konstan yang kedua kita dapat menjumlahkan selrurh konstan yang terdapat
pada f1(n) untuk di letakan pada g(n) sehingga menghasilkan 32n3 . Dengan demikian akan
menghasilkan c1.n3 f1(n)  c2.n dan kita sudah dapat membuktikannya, penyelsaian untuk
pernyataan nomer 2 mirip dengan yang pertama. Contoh lain untuk memahami notasi theta
adalah sebagai berikut, apakah 2n+1 Θ(22n) ? jawabannya adalah BUKAN/TIDAK, karena
2n+1O(22n) tetapi 2n+1 Ω (22n). Sekarang perhatikan fungsi berikut.

function find-min(array a[1..n])

let j :=
for i := 1 to n:
j := min(j, a[i])
return j
end
Seberapa besar atau kecil dari array tersebut, setiap kali kita jalankan find-min, kita
harus menginisialisasikan variabel i dan j serta mengembailkn j di akhir fungsi. Dengan
demikian, kita perlu berpikir bahwa bagian dari fungsi tersebut sebagai konstan dan
mengabaikannya.
Jadi bagaimana kita menggunakan notasi asimptotik untuk fungsi find-min? Jika kita
cari melalui array dengan 187 elemen, maka iterasi for loop dilakukan 187 kali, bahkan jika
elemen pertama yang kita akan cari berupa nilai terkecil. Sehingga untuk n elemen, maka
iterasi pada for loop dilakukan sebanyak n kali. Dengan demikian kita katakana fungsi
tersebut berjalan pada waktu tempuh O(n).

45
3.3. RINGKASAN
Dalam bab ini kita dapat simpulkan beberapa pelajaran penting dalam rangka
memahami notasi asimtotik untuk keperluan melakukan analisa algoritma sebagai usaha
menentukan klasifikasi algoritma :
■ Terdapat 3 (tiga notasi) yaitu ,  dan O untuk mengklasifikasikan suatu
algoritma pada order fungsi, dengan mengabaikan constant multiplier dan
memperhatikan besar dari input size n yang cenderung ke .
■ Fungsi f  (g) adalah equivalen dengan fungsi f mendekati atau mirip dengan
fungsi g.
■ Fungsi f  O(g) adalah equivalen dengan fungsi f tidak lebih besar atau sama
dengan fungsi g.
■ Fungsi f  (g) adalah equivalen dengan fungsi f lebih besar atau sama dengan
fungsi g
■ Estimasi waktu tempuh suatu algoritma di ekspresikan dengan menggunakan
notasi pada no 1
Atau secara lebih sistematis dapat di simpulkan sebagai berikut, diberikan suatu fungsi f
non negatif, sehingga terdapat 3 batas fungsi asimtotik yang umum sebagai berikut :
 Kita katakan bahwa f(n) adalah Big-O (O) dari g(n), ditulis sebagai f(n)=O(g(n)), bila
dan hanya bila terdapat konstan positif c dan n0 sedemikian rupa sehingga,
0  f ( n)  c . g ( n), n  n0
Jika f(n)=O(g(n)), kita katakan bahwa g(n) merupakan batas atas (upper bound) pada
f(n).

 Kita katakan bahwa f(n) adalah Big-Omega() dari g(n), ditulis sebagai f(n)
= (g(n)), bila dan hanya bila terdapat konstan positif c dan n0 sedemikian rupa
sehingga,
0  c . g ( n)  f ( n), n  n0

Jika f(n)= (g(n)), kita katakan bahwa g(n) merupakan batas bawah (lower bound)
pada f(n).

46
  Kita katakan bahwa f(n) adalah Big-Theta () dari g(n), ditulis sebagai f(n)= (g(n)),
bila dan hanya bila terdapat konstan positif c dan n0 sedemikian rupa sehingga,
c1 . g ( n)  f ( n)  c 2 . g ( n), n  n0

Secara ekivalen, f(n)=(g(n)), bila dan hanya bila f(n)=O(g(n)) dan f(n)=(g(n)), jika
f(n)=(g(n)) kita katakan bahwa g(n) merupakan batas ketat (upper bound) pada f(n).
Catatan : Kadang kala notasi f(n)O(g(n)) sering di pakai daripada f(n)=O(g(n))
begitu juga pada ( dan  ). Hal tersebut secara esensial berarti sama dan di pakai
secara umum.

Pembuktian Batas-batas
Ada 2 (dua) cara yang umum untuk melakukan pembuktian atas batas-batas seperti
diatas. Pertama menurut definisi di atas dan kedua menggunakan pendekatan yang lebih
mudah yaitu memakai teroremaa sebagai berikut :

Teorema 1 Limit fungsi

Di berikan f(n) dan g(n) suatu fungsi sedemikian rupa sehingga :

f ( n)
lim A
n  g( n)
Maka
1. Jika A=0, maka f(n)=O(g(n)) dan f(n) (g(n)).
2. Jika A=, maka f(n)=  (g(n)) dan f(n) (g(n)).
3. Jika A 0, maka f(n)= (g(n)).

Jika limit di atas tidak ada, maka teknik yang pertama di pakai (by definition). Untungnya,
dalam analisis algoritma, pendekatan di atas dapat bekerja hingga saat ini.
Sekarang kita akan melihat teorema penting dalam komputasi limit yang di sebut aturan
l’Hopital.
Teorema 2. Aturan l’Hopital.

47
Di berikan f(x) dan g(x) suatu fungsi yang dapat di turunkan (differentiable). Jika
lim f ( x )  lim g ( x )  0 atau lim f ( x )  lim g ( x )  
n  n  n  n 

Maka
f ( x) f '( x)
lim  lim
n  g( x ) n   g' ( x )

48
Latihan Soal

Tentukan Notasi asimptotik pada fungsi di bawah ini

function find-min-plus-max(array a[1..n])

// Pertama, cari elemen terkecil dalam array
let j := ;
for i := 1 to n do
j := min(j, a[i])
minim := j

// sekarang, cari elemen terbesar, tambahkan ke yang terkecil

j := ;
for i := 1 to n do
j := max(j, a[i])
maxim := j

// return jumlahan max dan min

return minim + maxim;
end
1. Perhatikan fungsi f(n)=3n2-n+4, menggunakan definisi 1, tunjukan bahwa fungsi tersebut
berada dalam f(n)=O(n2).
2. Perhatikan fungsi f(n)=3n2-n+4 . menggunakan definisi 2, tunjukan bahwa fungsi tersebut
berada dalam f(n)=(n2).
3. Perhatikan fungsi f(n)=3n2-n+4 dan g(n)= n log n +5, menggunakan teorema 6 , tunjukan
bahwa f(n)+g(n) = O(n2)
4. Buktikan jika f(x)=O(g(x)) dan g(x)=O(f(x)), maka f(x)=  (g(x)).
5. Di berikan fungsi f(x)=O(g(x)) dan g(x)=O(h(x)), Tunjukan bahwa f(x)=O(h(x)).
6. Temukan Theta (tight bound) dari f ( x )  x 8  7 x 7  10 x 5  2 x 4  3 x 2  17
4 3 2
7. Cari Theta dari f ( x )  x  23 x  12 x  15 x  21
8. Buktikan log x = O(x)
9. Tunjukan bahwa n!=O(nn)
10. Buktikan log n! = O(n log n)
11. Tunjukan untuk batas pada  (upper bound) : n log (n2+1)+n2 log n
12. Buktikan ( 2 ) log n  O ( n ) dimana log adalah basis 2
13. Tunjukan bahwa 2x=O(3x)

49
 BAB IV
KOMPLEKSITAS WAKTU DAN EFISIENSI ALGORITMA

4.1. PENDAHULUAN
Pada suatu algoritma umumnya yang di perlukan ada 3 hal adalah space, yaitu alokasi
yang bersifat statis atau dinamis , waktu tempuh, yang di dasarkan atas struktur program,
disini menyangkut pada berapa banyak langkah yang di perlukan untuk menjalankan
algoritma tersebut dan rekursif, pemakaian fungsi rekursif pada suatu algoritma. Dengan
memanfaatkan model RAM (Random Access Machine) yang sudah kita definisikan di bab
sebelumnya, kita akan menentukan waktu tempuh secara lebih rinci pada bab ini. Model RAM
membantu kita untuk menentukan waktu tempuh pada algoritma, namun demikian perlu juga
untuk mengetahui space dan pemanggilan pada fungsi rekursif pada suatu algoritma,
walaupun bukan menjadi tujuan utama kuliah ini. Semua aturan dalam RAM akan kita pakai
pada pembahasan bab ini. Tujuan utama pada bagian ini adalah menentukan pengukuran atau
perhitungan kompleksitas algoritma pada suatu fragmen kode yang di berikan,space yang di
perlukan baik pada algoritma non-rekursif maupun rekursif. Pembahasan pada fungsi non
rekursif tidak dilakukan secara mendalam pada bagian ini, dan hanya di batasi pada
penyelesaian secara trial dan error. Karena keterbatasan alokasi waktu maka pada transformasi
rekursif ke non rekursif akan di bahas pada buku yang lain dan waktu yang berbeda.

4.2. PENGUKURAN
Efisiensi untuk suatu algoritma tidak diukur dengan satuan waktu (detik, milidetik, dsb),
walaupun dalam simulasi hal tersebut dapat dilakukan, namun untuk tujuan yang lebih umum
waktu tempuh suatu algoritma sangat bergantung pada :
a) Banyaknya data  problem size
b) Spesifikasi komputer  Hardware (RAM, processor, dll)
c) Kompiler  software
d) Tegangan listrik  contoh kasusnya, pemakaian notebook menggunakan daya baterai
juga berpengaruh pada waktu tempuhnya karena kerja processor dapat dikatakan kurang
normal.

50
e) Unsur manusia.  programmer
Kebergantungan tersebut sudah diatasi dengan model RAM, dan oleh karena itu perlu di
lakukan studi terhadap setidaknya waktu tempuh, penggunaan space memori, pergerakan data
dan stabilitasnya, dalam bentuk fungsi waktu T(n) yang menjadi hasil akhir pengukuran
algoritma.

4.2.1. EFISIENSI WAKTU

Efisiensi waktu algoritma diukur dalam satuan n (problem size) yang cukup besar. 4
langkah untuk menentukan ukuran efisiensi waktu, antara lain :
a) Menentukan problem size (n)

Gambar 19. Problem Size

b) Menentukan operasi dominan

Operasi dominan yang dimaksudkan di sini sangat bergantung pada permasalahan, dan operasi
yang dilakukan yang banyaknya bergantung pada n, dengan kata lain operasi dominan
merupakan operasi yang paling banyak dilakukan, sesuai konteks permasalahan.
Contohnya,
(1) Pada algoritma menentukan max/min  operasi dominannya adalah operasi
perbandingan “<” atau “>”
(2) Pada algoritma searching  operasi dominannya adalah operasi “=”

51
 (3) Pada algoritma sorting  operasi dominannya adalah operasi “<” atau “>” operasi
yang lain seperti “” tidak dominan, karena belum tentu terjadi penukaran atau
perpindahan (contoh kasus : jika data yang diinputkan sudah dalam keadaan terurut)
(4) Pada algoritma menentukan rata-rata  operasi dominannya adalah penjumlahan (+)
(5) Pada algoritma perkalian 2 matriks  operasi dominannya adalah perkalian, sedangkan
operasi dominan yang keduanya (2nd dominant operation) adalah penjumlahan atau
pengurangan
(6) Pada algoritma menentukan modus  operasi dominannya adalah pembandingan “<”
atau “>” yang terjadi dalam proses pengurutan, lalu diikuti dengan operasi dominan
yang keduanya (2nd dominant operation) adalah pembandingan “=” yang terjadi dalam
proses menghitung frekuensi dari masing-masing data
c) Menentukan fungsi langkah  g(n)
g(n) = banyak kali operasi dominan dilakukan (dalam n)
Contohnya,

Tanpa Else

Dengan Else

Gambar 20. Perbedaan dengan else dan tanpa else algoritma min max

d) Menentukan kompleksitas waktu O(f(n)) (Big Oh function)

Suatu algoritma dengan fungsi langkah g(n) dikatakan mempunyai kompleksitas waktu
O(f(n)) jika terdapat konstanta c>0 sedemikian hingga : g(n)≤c.f(n) untuk n>n0 , contoh
(1) Algoritma MaxMin, CountingSort  g(n) = 2n-2  Ο(n) Linear
(2) Algoritma BubbleSort  g(n) = n /2-n/2  O(n2) Kwadratik
2

(3) Algoritma Perkalian 2 matrix nxn  g(n) = n3 + kn  O(n3) Kubik

52
 (4) Algoritma MergeSort, QuickSort  g(n)=nlogn O(n log n) Logaritmik
Tentukan g(n) dan Big Oh function dari algoritma di bawah ini ?
k=n
while k > 0 do begin
for i = 1 to n do
if (x > 0) then . . . .
k = k div 2
end
Jawaban : g(n) = n log n + 1, O(n log n)
e) Memahami kompleksitas waktu batas bawah O(f(n))
Ketika diadakan percobaan untuk mengetahui waktu tempuh beberapa algoritma dengan
berbagai jumlah data yang bervariasi, diperoleh data sebagai berikut, Waktu tempuh algoritma
menentukan max/min berbanding lurus dengan banyaknya data.
(1) Contohnya,
Tabel 8. Waktu tempuh Min max
N waktu tempuh (milidetik)
1.000.000 20
2.000.000 40
4.000.000 80
pada O(n), yang bersifat linear, diketahui semakin besar jumlah datanya, akan
semakin stabil linearitasnya.
(2) Contoh kasus menentukan algoritma min/max, seperti tabel algoritma sebelumnya.
Tabel 9. Waktu tempuh Min max dengan else dan tanpa else
N T(n) dengan else T(n) dengan tanpa else
1.000.000 10 10
10.000.000 120 110
20.000.000 150 120
30.000.000 220 170
40.000.000 290 220
50.000.000 360 290
100.000.000 720 560
1 Milyar 7200 5600
Pada contoh algoritma ini di perloeh keadaan best case, yakni ketika data di urutkan
secara ascending, dan akan di peroleh worst case ketika data diurutkan secara descending,
karena data terbesar berada pada elemen pertama.
(3) Algoritma kuadratik pada sorting

53
 Tabel 10. Perbandingan Waktu tempuh Sekuensian dan Buble sort
n Sekuensial Bubble
10.000 580 460
20.000 1.890 1.800
30.000 4.000 4.095
40.000 6.900 7.260
50.000 10.435 11.325
100.000 36.200 45.415
Prediksi 1.000.000 3.620.000 4.541.500
(4) Pada algoritma perkalian 2 matriks  g(n) =n3

N waktu tempuh
100 40
200 320
300 730
400 1.762
500 3.425
600 5.850
700 9.160
800 13.760
900 19.360
1.000 26.380

Gambar 21. Waktu tempuh 2 Algoritma Perkalian matrik

4.2.2. EFISIENSI SPACE MEMORI

Yaitu menentukan besar memory yang diperlukan oleh suatu algoritma. Kebutuhan
memory (space) suatu algoritma juga tidak bisa diukur dalam satuan memory (byte, KB),

54
karena kebutuhan memory yang sebenarnya bergantung dari banyak data dan struktur datanya.
Kebutuhan memory dari suatu algoritma diukur dalam satuan problem size n. Pada
pengukuran ini jika di simulasikan secara fungsional kita mudah mendapatkan konstruksi
memori yang di hasilkan oleh suatu algoritma, bahkan kebutuhan setiap fungsi dapat di ambil
dengan mudah.

4.2.3. KEMUDAHAN IMPLEMENTASI

Maksud dari kemudahan implementasi di sini adalah mengukur seberapa mudah/sederhana
algoritma tersebut dibuat programnya, hal ini bisa dilihat dari teknik perancangannya atau
struktur data yang digunakan. Biasanya sering digunakan dalam membandingkan suatu
algoritma dengan algoritma lainnya, dan bukan diukur dengan tingkatan seperti sulit, mudah,
atau pun sedang, kecuali penentuan problemnya. Misalnya, bila kita membandingkan
algoritma sekuensial sort dengan quick sort, ternyata algoritma sekuensial sort lebih mudah ,
karena quicksort menggunakan teknik devide & conquer. Sedangkan pada Pigeonhole Sort
lebih mudah dibandingkan dengan Radix Sort, karena Radix Sort menggunakan queue. Jadi
implementasi bukan menjadikan pengukuran yang dapat di katakana efisien karena kecepatan
pengkodeannya, namum pengkelasan teknik (di bahas pada bab lain pada buku ini)
penyelesaian masalah algoritma menjadi seperti contoh di atas menunjukan kreativitas
programmer dalam menyelesaikan masalah, di karenakan knowledge yang di milikinya.

4.2.4. DATA MOVEMENT (SORTING)

Unsur ini berusaha mencari tahu banyaknya peristiwa perpindahan atau penukaran yang
terjadi pada suatu algoritma sorting. Untuk mengetahui data movement ini kadang-kadang
menemui kesulitan, karena mungkin tidak pasti atau mungkin diperlukan perhitungan dan
penyelidikan yang lebih lanjut.

4.2.5. STABILITY (SORTING)

Algoritma dapat bersifat stabil atau tidak stabil. Stabilitas suatu algoritma dapat dilihat
dari kestabilan index data untuk data yang sama.

55
 Gambar 22. Stabilitas Sorting

4.3. EFISIENSI ALGORITMA

Dengan demikian setelah mengetahui property waktu dan space dalam mengukur efisiensi
suatu masalah, maka secara umum kita dapat mengkonstruksi efisiensi algoritma secara
umum. Algoritma dalam hal ini aka di konstruksi berdasarkan fungsi dan modul yang
membagun suatu algoritma secara utuh (program). Jadi mungkin saja suatu algoritma
memanfaatkan modul lain dari algoritma yang sudah ada. Dengan mengetahui property
tersebut maka kita akan mengukur performa algoritma secara keseluruhan.

Contoh :

s=0 (a)
for i=1 to n do
s=s+i (b)
write(s) (c)
Analisis :

(1) Dari fragmen program diatas, maka dapat di analisa sebagai berikut :
(2) Bagian (a) di eksekusi 1 kali
(3) Bagian (b) merupakan suatu loop, yang didasarkan atas kenaikan harga i dari i=1
hingga i=n. Jadi statemen s=s+i akan diproses sebanyak n kali sesuai kenaikan harga i
(4) Bagian (c) akan diproses 1 kali
(5) Karena bagian (b) merupakan bagian paling yang paling sering dip roses, maka bagian
(b) merupakan operasi aktif, sedang (a) dan (c) dapat di abaikan karena bagian tersebut
tidak sering diproses.

56
 (6) Bagian (b) dip roses sama dengan banyak data yang di masukan (n). Maka program
penjumlahan bilangan riil tersebut mempunyai order sebanding dengan n atau O(n).
Contoh :

for i=2 to n do
a=2*n+i*n
Analisis :
Jumlah pemrosesan a=2*n+i*n mengikuti iterasi dalam i, yaitu dari i=2 hingga i=n,
jadi sebanyak (n-2)+1=(n-1) kali. Perhatikan disini yang penting bukanlah berapa nilai
variable a (yang merupakan fungsi dari i dan n), tapi keseringan pemrosesan a. Sehingga
algoritma tadi berorder O(n)

Contoh :
for i=1 to n do
for j=1 to i do
a=n+i*j
Analisis :
• Pada i=1, j berjalan dari 1 hingga 1 sehingga a diproses 1 kali
• Pada i=2, j berjalan dari 1 hingga 2 sehingga a diproses 2 kali
• Pada i=3, j berjalan dari 1 hingga 3 sehingga a diproses 3 kali
• … dan seterusnya
• Pada i=n, j berjalan dari 1 hingga n sehingga a diproses n kali
• Secara keseluruhan A akan dip roses sebanyak (1+2+3+…+n)=
n(n  1) 1 2 1
 n  n
2 2 2 kali, dan algoritma tersebut mempunyai order O(n2).

4.4. SPACE DAN MEMORY

Dalam sub bab sebelumnya efisiensi space sudah di bahas, namun dalam bagian ini akan
di bahas lebih pada penggunaan memory dalam pengukuran secara detail. Persoalan yang
mendasar adalah bagaimana mengkonversi space (dalam satuan byte) ke langkah. Salah satu
cara yang paling mudah adalah dengan menghilangkan satuannya (byte), selain itu juga
dengan asumsi tipe data dinamis di perhitungkan pada alokasi awal. Dengan cara ini space

57
dapat di tentukan bersama komponen lain. Namun demikian untuk keperluan latihan dan
pemahaman, penentuan kebutuhan memory dapat di spesifikasian dan di intrepretasikan
tersendiri sesuai kebutuhan kuliah.

4.4.1. PROCEDURE/FUNCTION CALL

Pada bagian ini analisa lebih cenderung di pandang bagaimana suatu operasi di lakukan
pada level bawah (low level), yaitu pada level pemroses melakukan operasi secara mikro di
prosesor dan hal ini juga tergantung pada compiler yang di pergunakan, apakah optimasi dapat
dilakukan/diberikan atau tidak. int x=5*3, dianggap 1 langkah, karena di dalam ekspresi ada
operator dan jumlahnya hanya 2, yaitu tanda operator *, serta 1 assignment. int x=5*3+4,
dianggap 3 langkah karena di dalam ekspresi tersebut ada 2 operator (*,+), ditambah 1
assignment.
Penggunaan built-in procedure/function adalah di anggap 1 langkah, ditambah dengan
banyak parameter >1 dan operator di dalam parameter tersebut. Misal ada pemanggilan seperti
berikut sin(x), maka di anggap 1 langkah, atau sin(x*2) diangap 2 langkah. Assigment dari
suatu konstanta dianggap 1 langkah, misal const x=5.
Contoh latihan :

function sinus (x) : real;

begin
sinus := 0;
for i : = 0 to 1000 do
if i mod 2 = 0 then d:= 1
else
d:= - 1
jum:=jum+d*exp((2*i+1)*ln(x))/fakt(2 * i + 1)
sinus : = jum
end

Waktu Tempuh = Space + Banyak Langkah

4.4.2. STRUKTUR PROGRAM
Analisa terhadap Struktur Program akan menyangkut banyak langkah, yang di pengaruhi
oleh :

58
 a) Banyak operator yang di gunakan, asumsi 1 operator adalah 1 langkah, kecuali untuk
pangkat (^) dan modulo (%) di hitung 2 langkah
b) Kontrol langkah (sekuensial, struktur kondisi dan perulangan)

4.4.2.1. OPERATOR, ARRAY DAN POINTER

Operator yang akan di ukur adalah seluruh operator yang di ijinkan dalam model RAM,
diantaranya, operator aritmatika, logika, relasional, Boolean dan operator lainnya yang mirip
dalam bahasa c.

Operator logika : AND, OR, NOT, XOR dan sejenisnya dihitung 1 langkah
Operator aritmatik : +,-,*,/ di hitung 1 langkah
Operator aritmatik : ^ (pangka) dan % atau mod di hitung 2 langkah
Operator Relasional : <,>,!=,>=,<= di hitung 1 langkah
Operator Logika : And,Or, Xor dan Not di hitung 1 langkah
Contoh :
not(p and q) mempunyai langkah sebanyak 2
not(x > 0) and (y > 0) mempunyai langkah sebanyak 4
C nk   (nk) C = kombinasi
Cn k
lim k  C Cnk  O (nk) Ω (nk)
n  n

Array 1 dimensi dan akses pointer di hitung 2 langkah, sedangkan untuk 2 dmensi di hitung 4
langkah seperti di bahas pada bab 2.
4.4.2.2. SEKUENSIAL
Misal ada suatu statemen sebagai berikut,
Statemen s1 dengan t1 langkah
Statemen s2 dengan t2 langkah
Maka banyak langkah statemen gabungannya adalah t1+t2 atau
S1 banyak langkah P1
S2 banyak langkah P2
S3 banyak langkah P3
. .

Sn banyak langkah Pn
n

P
i 1
i 59
Total banyak langkah blok-blok statement tersebut adalah Si bisa berupa : assigment,
procedure call, percentage, kalang, dan sebagainya.
Contoh :
xx*y operasi 2 =2
y  a * sin(x) operasi 3, proc 1, param 1 =4
read (b) proc 1,param 1 =2
write (x + y + b) proc 1, operasi 2, param 1 =4+
Banyak Langkah = 12

4.4.2.3. BRANCHING
Bentuk Umum dari kondisional adalah sebagai berikut :
if (k) s1 else s2
k = kondisi dengan banyak langkah sebesar c, tergantung ekspresi di dalamnya sedang s1,s2 =
blok statement dengan banyak langkah P1, P2. Misal :
kondisi mempunyai k langkah, s1 mempunyai p1 langkah dan s2 mempunyai p2 langkah
maka langkah terburuk adalah k+max(p1,p2), dan langkah terbaik adalah k+min(p1,p2), yang
digunakan dalam menentukan banyak langkah dalam suatu pencabangan adalah kasus
terburuk yaitu k+max(t1,t2). Contoh :
if x>0 then // c = 1
x:=x-1 // p1 = 2
y:=x+y
else
y:=x-y // p2 = 1

Analisa.
Banyak kondisi adalah 1, dengan 1 operator, sedangkan banyak langkah di bedakan atas
kondisi true, terdapat 2 langkah dan kondisi false terdapat 1 langkah, maka perhitungan dapat
di lakukan dengan menuliskan c+max(p1,p2)=1+2=3 langkah. Contoh lainnya,
input(x); // 1 langkah
y=x+5; // 1 langkah
if (x>0) then // 1 c
y:=y-5; // 2 langkah
x:=x-y;
else
x=abs(x); // 1 langkah

Total waktu tempuh fragmen di atas adalah 2+1+max(2,1) = 5 langkah.

60
4.4.2.4. LOOPING
Perulangan menjadi topic yang menarik dalam analisia algoritma, sebab sebagian besar
algoritma ditentukan oleh operasi dominan di dalamnya, dan perulangan menjadi operasi
dominan yang sering dipakai dalam algoritma. Ada banyak varian dari bentuk loop, salah satu
varian yang mudah untuk di hitung adalah bentuk loop for. Bukan berarti bentuk lainnya tidak
dapat di hitung, hanya saja jika kita ingin mempermudah harus mentranslasikan dalam bentuk
for, misal bentuk while do atau while, bentuk repeat until atau do while.

x=5 do{
while (x>0){ .
. .
. input(x);
input(x) }while (x>0)
}
Gambar 23. Bentuk Loop unpredictable
Pada bentuk di atas, x tidak dapat di ketahui akan di baca berapa kali. Untuk bentuk yang
seperti diatas, sangat sulit untuk di analisa, dengan demikian analisa di pastikan pada bentuk
yang sudah pasti, misal pada bentuk for loop berikut :
for (i=awal,i=akhir;i=+5){
.
input(i);
}
Nilai i hanya bisa di gunakan dalam statemen di bawah for (bersifat lokal pada kalang for)
Jadi for loop lebih mudah di analisis.
4.4.2.4.1. FOR LOOP KASUS 1
Pada bentuk loop pertama ini suatu statemen akan di kerjakan sebanyak step atau counter
pada loop yang bersifat default, yaitu di ikremen sebanyak 1 kali saja.
Counter : integer
Step : 1 = default

Pada bentuk ini statement S mempunyai banyak langkah yang tidak bergantung nilai counter.
for counter : awal to akhir for (awal;akhir;counter)
S S

61
S dieksekusi sebanyak akhir – awal +1 kali
Keterangan :
Counter ≤ Akhir , S dieksekusi sebanyak akhir – awal + 2 kali
Counter = counter + 1 , S dieksekusi sebanyak akhir – awal + 1 kali
RUMUS UMUM

Banyak Langkah : (akhir – awal + 2) + (akhir – awal + 1) (p + 1)

Dengan p adalah banyak langkah dalam statement dalam loop.

Contoh :
for (x=0;x<n;x++) atau for x:=0 to n-1 do
Contoh :
Berapa banyak langkah dari
for i = 1 to n do
x : = x + 5; // 2
y : = y + x; // 2 jadi p=4

Penyelesaian :
# Langkah = (akhir – awal + 2) + (akhir – awal + 1) (p + 1)
= (n – 1 + 2) + (n – 1 + 1) (4 + 1)
= (n + 1) + (n)(3)
= n + 1 + 3n
= 4n + 1
4.4.2.4.2. FOR LOOP KASUS 2
Pada kasus kedua, loop dengan jumlah langkah counter atau step = s , dimana s dieksekusi
sebanyak  akhir  awal  1
 s 

Atau dengan kata lain adalah ((akhir – awal) div s + 1)

Contoh :
Berapa banyak langkah dari
for i:= j to n step 3 do
x := x + i
y := y + j

 akhir  awal  +  akhir  awal  (p + 1)

  2   1
s  s 

62
 n j  n j 
  2    14  1
 3   3 
n j  n j 
  2    15
 3   3 
n j   n j 
  2    5.  5
 3   3 
n j n j
 2  5. 5
3 3
n j n j
6 7 Jadi 6  7  O ( n) Pd (n)  O (nd ) , P = Polinomial, d = Derajat
3 3

Contoh Berapa banyak langkah dari fragmen berikut,

for i = 0.5 to 7.1 step 0.3 do
x := x + i
y := y + j
 akhir  awal  +  akhir  awal  (p + 1)
  2  1
s   s
 
 7,1  0,5   7,1  0,5 
  2    12  1
 0,3   0,3 
 6,6   6,6 
  2    13
 0,3   0,3 
=(22 + 2) + (22 + 1) . 3
=24 + 23. 3 =24 + 69 = 93

4.4.2.4.3. FOR LOOP KASUS 3

Loop pada kasus yang terakhir ini, mempunyai format bahwa nilai awal loop bergantung pada
loop lainnya, dan biasanya terjadi pada nested loop

for i:=1 to n do Outer Loop

x:=x+y
Statemen S
for j:=i to n do
y:=i+j Inner loop

Bentuk loop di atas berupa nested loop, dalam bentuk ini sering terjadi bahwa nilai awal inner
loop bergantung pada besar nilai counter dari outer loop. Perlu diperhatikan juga bagian kode
yang di beri highlight abu-abu, yang menunjukan kebergantungan nilai awal inner loop pada
63
counter outer loop. Untuk menghiutng contoh di atas maka kita dapat menyelesaikan sebagai
berikut :

Inner loop (akhir-awal+2)+ (akhir-awal+1)(p+1)

((n-i)+2)+ ((n-i)+1)(2+1)
((n-i)+2)+ ((n-i)+1).3
((n-i)+2)+ 3(n-i)+3
3(n-i)+5
3n-3i+5
P(i) step dalam outer + step dalam inner
2+3n-3i+5
3n-3i+7

Outer loop (akhir-awal+2)+ (akhir-awal+1)(p+1)

(akhir-awal+2)+ (akhir-awal+1).1+P(i)
n
((n-1)+2)+ ((n-1)+1).1+  P (i )
i

n
((n-1)+2)+ ((n-1)+1).1+  (3n  3i  7 )
i

n n n
2n+1+n+  3n   3i   7
i i i

n(n  1
(3n+1+3n2-3.( )+7n).(2)
2
6n+6+6n2-3n2+3n+14n
3n2+20n+6  O(n2)

64
Latihan Soal
1. Untuk fragmen berikut, tentukan waktu tempuh dan order fungsinya.
for i= 1 to n2 do
a[i]:= x*y
for j=1 to n do
if x>y then
temp=x
x=y
y:=temp
else
x=3*y+1
2. Tulislah algoritma Sequiential Search dan buktikan bahwa algoritma tersebut berada pada
order O(n).

3. Tulislah algoritma Binary Search dan tentukan waktu tempuh serta order fungsinya.

4. Perhatikan problem berikut :

Balik dan Tambah
Diberikan suatu bilangan N, lakukan pembalikan digit dari N, lalu tambahkan dengan
dengan bilangan tersebut hingga hasil penjumlahan berupa digit palindrome. Contoh
N=195
195
591
786
687
1473
3741
5214
4125
PROBLEM
9339
{*
Sample Input
3
195
265
750
Sample Output
4 9339
5 45254
3 6666
*}
N suatu integer positif, 100<N<1000
INPUT
Contoh input :
OUTPUT Suatu palindrome dari digit yang terbentuk
ALGORITMA User define
Tentukan waktu tempuh dan order fungsi dari algoritma yang anda buat.?

65
 BAB V
RECURSIVE CALL

5.1. BEPIKIR REKURSIF

Secara informal, rekursi adalah proses untuk menyelesaikan masalah besar dengan
membagi menjadi satu atau lebih sub masalah yang mana (1) secara struktur identik dengan
masalah asalnya, (2) sedemikian rupa sehingga masalah mudah atau secara sederhana mudah
di pecahkan. Sekali pembagian masalah sudah di buat, teknik dekomposisi yang sama yang di
gunakan untuk membagi sub masalah tersebut ke dalam satu sub divisi penyelesaian masalah
baru yang sudah tidak berkurang kompleksitasnya. Sering kali , sub- problem menjadi begitu
sederhana sehingga dapat di selesaikan tanpa pembagian sub-divisi lainnya, dan solusi di
dapatkan dengan merakit kembali komponen sub permasalahan yang sudah di pecah
sebelumnya. Ada beberapa karakteristik yang di perlukan dalam penyelesaian masalah
rekursif ini, pertama jika masalah cukup di selesaikan secara sederhana, maka lakukanlah,
biasanya pada property ini sifatnya adalah basis, artinya terdapat suatu kondisi dimana
masalah dasar ini dapat di selesaiakan tanpa rekursivitas. Sehingga property ini biasa di sebut
sebagai basis atau stopping criteria. Kedua, jika masalah tidak memenuhi untuk di selesaikan
secara basis (mungkin saja basis tidak hanya berjumlah satu), maka ada kondisi yang
menyebabkan rekursivitas di panggil, ini di sebut suatu kondisi rekursif. Dan yang terakhir
adalah suatu penyelesaian secara rekursif, biasanya dalam bentuk suatu ekspresi rekursif, yang
di dalamnya terdapat suatu operasi yang nilainya menuju ke basis, dengan demikian sifat
rekursifnya akan selalu berakhir ke nilai yang menuju ke basisnya atau stopping kriterianya.
Pada bagian selanjutnya akan di bahas pemanggilan fungsi secara rekursif, disini lebih banyak
di berikan latihan penyelesaian pemanggilan fungsi secara rekursif dengan cara yang
sederhana, yaitu coba-coba dan tidak di bahas solving reccurence terhadapnya.

5.2. PEMANGGILAN FUNGSI REKURSIF

Suatu analisis terhadap pemanggilan fungsi rekursif yang di hitung dari :
- Banyak langkah non rekursif
- Banyak langkah fungsi tersebut dalam bentuk rekursif

66
Karena dalam terminology rekursif mengandung 3 hal yaitu :
- Nilai awal (basis) pada fungsi sebagai stoping criteria atau ekspresi non
rekursif
- Kondisi yang menyebabkan rekursif
- Ekspresi rekursif karena kondisi rekursif terpenuhi dan nilai parameternya
selalu menuju ke nilai awal/basis.
Contoh :
fak(n)
if n=0 and n=1 then fak=1 ada 3 step dalam c (non-rekursif)
else fak=n*fak(n-1) 3 step rekursif

T(n) adalah waktu yg di perlukan utk memanggil fak(n)

Jika n=0 dan n=1 maka T(0)=2  konstanta (c)

Jika n>1 maka T(n)=T(n-1)+3, krn ada 2 operator (* dan -) , 1 param
Secara matematis ditulis dengan
 2, n  0
T ( n)  
T ( n  1)  2, n  1

Contoh lain

67
Contoh lagi
Procedure Bla(x,y,n)
If n0 then
Y=x+1
Write(x,y)
Else
For i=1 to n do
Y=x+y
X=x+y
Bla(x,y,n-1)
Analisis :
((n-1)+2)+((n-1)+1)(p+1)
((n-1)+2)+((n-1)+1)(2+1)
((n-1)+2)+((n-1)+1) 3
((n-1)+2)+(3(n-1)+3)
((n-1)+2)+(3n-3+3)
((n-1)+2)+3n
4n+1
Buktikan :
T(0)=3  c
T(n)=4n+1+1+T(n-1)
T(n)=T(n-1)+4n+2
Jadi
 c, n  0
T ( n)  
T ( n  1)  4n  2, n  1
Contoh Lain

Analisa Untuk procedure test :

68
 T(n)=2n+c+3n+c+(T(n-1)+c)+(T(n-2)+c)+(T(n-2)+c)
T(n)=2T(n-2)+T(n-1)+5n+7c
T(n)=5n+T(n-1)+2T(n-2)+7c
Jika c=0, maka
T(n)=5n+T(n-1)+T(n-2)
Sehingga di peroleh,

 2, n  1,2
T ( n)  
5n  T ( n  1)  2T ( n  2), n  2

69
 BAB VI ALGORITMA BRUTEFORCE

“Brute force merupakan pendekatan straightforward untuk menyelesaikan masalah,

biasanya secara langusng di dasarkan pada definisi dan pernyataan masalah dari konsep yang
di maksudkan”. Strategi solusi di dasarkan pada kekuatan komputasi pada komputer, bukan
pada intelektual programmer (”Just do it!” approach).
Contoh-contoh
Hitung an , dari bilangan a dan n, jawabanya an = a*a*a* ….*a, (a di kalikan dengan a
sebanyak n kali),

5.1. SELECTION SORT

Kita memeriksa suatu list untuk menemukan elemen terkecil, lalu kita letakan dalam
posisi terakhir. Kita periksa lagi sisa dari daftar tersebut, cari elemen kedua yang terkecil. Kita
letakan pada posisi kanannya dan seterusnya. Untuk membuat Algoritma ini bekerja pada
tempatnya kita menggunakan suatu array. Kita simpan index dari elemen terkecil dan
meletakkannya pada awal array, lalu kita temukan elemen kedua terkecil dan meletakkannya
pada posisi kedua, pisahkan array menjadi dua bagian, pada bagian awal terurut dan yang
terakhir tidak terurut.

//Input: Larik A tidak terurut

//Output: Larik A sudah terurut
SelectionSort(A[0..n-1])
for i = 0 to n-2 do
min = i;
for j = i +1 to n-1 do
if A[j] < A[min] then min = j;
swap A[i] and A[min];

70
 89 45 68 90 29 34 17
17 45 68 90 29 34 89
17 29 68 90 45 34 89
17 29 34 90 45 68 89
17 29 34 45 90 68 89
17 29 34 45 68 90 89
17 29 34 45 68 89 90
Operasi dasarnya adalah melakukan perbandingan A[j] < A[min]
Waktu eksekusi bilangan adalah :

5.2. BUBBLE SORT

Membandingkan elemen tetangganya dari suatu list, lalu menukarnya jika tidak terurut.

BubbleSort(A[0..n-1])
for i = 0 to n - 2 do
for j = 0 to n - 2 – i do
if A[j+1] < A[j] then
swap A[j] and A[j+1];

5.3. SEQUENTIAL SEARCH

Periksa list dengan kunci yang di berikan. Kita dapat menambahkan key di akhir list
SequentialSearch2(A[0..n],K)
A[n] = K; i = 0;
while A[i] != K do
i = i +1;
if i < n return i;

71
else return -1;

5.4. STRING MATCHING

Misalkan kita punya string dengan panjang n karakter- text dan string dengan m
karakter – pattern (n>m). String matching artnya adalah menemukan substring dari text
yang cocok dengan pattern.
Brute force algorithm:
Batas pattern terhadap m karakter pertama text dan mulai mencocokan dengan
pasangan yagn berhubungan hingga seluruh karakter cocok atau pasangan tidak di temukan .
Jika pasangan tidak ada yang cocok, pattern di geser satu posisi dan perbandingan di mulai
lagi.
BruteForceStringMatching(T[0..n-1],P[0..m-1])
for i = 0 to n-m do
j = 0;
while j < m and P[j] == T[i+j] do
j = j +1;
if j ==m return i;
return -1;
Pada kasus Worst case, kita perlu memeriksa seluruh karakter m sebanyak n-m+1 kali,
sehingga hasilnya Θ(n.m). Pada kasus Average case dalam teks random adalah Θ(n+m) =
Θ(n).
Pada Best case, pattern yang cocok dalam text dapat di perbandingkan sebanyak m kali
sehingga menjadi Θ(m). Dalam C dapat di tulis sebagai,
void BF(char *x, int m, char *y, int n) {
int i, j;
/* Searching */
for (j = 0; j <= n - m; ++j) {
for (i = 0; i < m && x[i] == y[i + j]; ++i);
if (i >= m)
OUTPUT(j);
}
72
}

Algoritma dapat di tulis ulang untuk mendapatkan efisiensi dalam praktek dengan :

#define EOS '\0'

void BF(char *x, int m, char *y, int n) {
char *yb;
/* Searching */
for (yb = y; *y != EOS; ++y)
if (memcmp(x, y, m) == 0)
OUTPUT(y - yb);
}
Atau dalam bentuk lainnya adalah sebagai berikut,

char *search(char *pat, char *text){

int m;

if( *pat == EOS ) return( text );

m = strlen(pat);
for( ; *text != EOS; text++ )
if( strncmp( pat, text, m ) == 0 ) return( text );
return( NULL );
}

Dari beberapa bentuk algoritma di atas, maka kita dapat melacak cara kerja dari algoritma
string matching sebagai berikut,

73
74
Gambar 10. String Matching

75
5.5. DUA TITIK TERDEKAT
Menemukan dua titik terdekat dari himpunan titik n. Kita hanya fokus pada ruang dua dimensi
. Titik di tentukan dengan koordinat (x,y). Jarak antara dua titik Pi=(xi,yi)dan Pj=(xj,yj)
merupakan jarak Euclidean d(Pi,Pj) = sqrt( (xi-xj)2 + (yi-yj)2 )

BruteForceClosestPoints(P)
//P adalah list dari n (n >=2) titik
dmin = ∞;
for i = 1 to n-1 do
for j = i+1 to n do
d = sqrt( (xi - xj)2 + (yi - yj)2 ) ;
if d < dmin then
dmin = d; index1 = i; index2 = j;
return index1,index2;

Untuk mempercepat algoritma kita hindari sqrt! Kita dapat membandingkan nilai (xi-xj)2 +
(yi-yj)2 secara langsung, operasi dasarnya adalah:

5.6. MENGHITUNG FAKTORIAL (N!)

n!= 1*2*3*4*…*n untuk n>0 dan 1 untuk n=0, Solusi bruteforce : Kalikan sejumlah n
bilangan secara bersamaan dimulai dari 1 hingga n.

BruteForceFaktorial(n)
Int I,fakto;
fakto=1;
76
for i = 1 to n do
fakto=fakto*i;
return fakto

5.7. PERKALIAN MATRIK N*N

Untuk matrik n*n, misalkan A dan B adalah matriknya, hasil kali matrik tersebut adalah
C= A*B sedemikian sehingga elemen-elemen matriknya adalah cij, aij danbij dengan demikian
di peroleh
n
cij=ai1b1j+ ai2b2j+…+ ainbnj=  a ik bkj
k 1

BruteForceMatrik(A[n][m] B[m][n])
C[n][n];i,j,k;
for i = 1 to n do
for j = 1 to n do
C[i][j]=0;
for k = 1 to n do
C[i][j]=C[i][j]+(A[i][j]* B[i][j])
return C[i][j];

5.8. MASALAH KOMBINATORIAL.

Kombinatorik men-generate tiap elemen dari domain masalah dan memilih di
antaranya yang memenuhi batasannya serta menemukan elemen yang diinginkan.

Traveling salesman Problem

Masalah, ada sejumlah n orang yang di beri tugas untuk melaksanakan pekerjaan
sejumlah n pekerjaan, satu orang per satu pekerjaan. Biaya/cost dari setiap orang adalah i
utnuk mengerjakan pekerjaan j adalah C[i,j]. Cari penugasan dengan cost terkecil.

job1 job2 job3 job4

orang1 9 2 7 8
orang 2 6 4 3 7
orang 3 5 8 1 8

77
 orang 4 7 6 9 4

Dengan melihat matrik diatas, solusinya dalah memilih satu elemen dalam tiap baris dari
seluruh elemen kolom yang berbeda dalam matrik lalu menjumlahkan total dari elemen
terkecil yang terpilih yang mungkin. Tidak ada strategi umum untuk pekerjaan ini. Kita akan
menggambarkan sebgai solusi n-touple <j1,…,jn>. Solusi ini memerlukan komputasi seluruh
permutasi dan jumlahan dari biaya/cost.
<1,2,3,4> cost = 18
<1,2,4,3> cost = 30
<1,3,2,4> cost = 24
Jumlah permutasinya adalah n!. Kita akan mengevaluasi seluruh permutasi ini dalam rangka
menemukan cost yang terkecil, order algoritma ini adalah O(n!).
(for n=4, n! = 4*3*2*1 = 24
n=5, n! = 5*4*3*2*1 = 120
n=6, n! = 6*(5!) = 720
n=7, n! = 7*(6!) =5040
n=8, n! = 8*(7!) = 40320)

Contoh :

Input :

infinity: 999
no. of cities: 4
no. of paths: 6

S D Dist
path0: 0 1 2
path1: 0 2 4
path2: 0 3 3
path3: 1 2 3
path4: 1 3 6
path5: 2 3 1

78
Proses Algoritma adalah sebagai berikut :

V V_N V_N-path ckt_length, ckt (started with MIN_CKT_LENGTH,

INFI,-) HAM_CKT (started with INFI,-)
0 1 1-2-3 9,0-1-2-3-0* 9,0-1-2-3-0
2 2-3-1 13,0-2-3-1-0 9,0-1-2-3-0
3 3-2-1 9,0-3-2-1-0* 9,0-3-2-1-0
1 0 0-3-2 9,1-0-3-2-1* 9,1-0-3-2-1
2 2-3-0 9,1-2-3-0-1* 9,1-2-3-0-1
3 3-2-0 13,1-3-2-0-1 9,1-2-3-0-1
2 0 0-1-3 13,2-0-1-3-2 9,1-2-3-0-1
1 1-0-3 9,2-1-0-3-2* 9,2-1-0-3-2
3 3-0-1 9,2-3-0-1-2* 9,2-3-0-1-2
3 0 0-1-2 9,3-0-1-2-3* 9,3-0-1-2-3
1 1-0-2 13,3-1-0-2-3 9,3-0-1-2-3
2 2-1-0 9,3-2-1-0-3* 9,3-2-1-0-3

79
 BAB VII
ALGORITMA GREEDY

7.1. PENDAHULUAN
Algoritma greedy merupakan metode yang paling populer untuk memecahkan
persoalan optimasi . Persoalan optimasi (optimization problems): persoalan yang menuntut
pencarian solusi optimum. Solusi optimum (terbaik) adalah solusi yang bernilai minimum atau
maksimum dari sekumpulan alternatif solusi yang mungkin. Elemen persoalan optimasi
adalah kendala (constraints) dan fungsi objektif(atau fungsi optiamsi) .
Solusi yang memenuhi semua kendala disebut solusi layak (feasible solution). Solusi layak
yang mengoptimumkan fungsi optimasi disebut solusi optimum.
Contoh masalah sehari-hari yang menggunakan prinsip greedy:
• Memilih beberapa jenis investasi (penanaman modal)
• Mencari jalur tersingkat dari Bandung ke Surabaya
• Memilih jurusan di Perguruan Tinggi
• Bermain kartu remi
Contoh kasus Penukaran uang, Misal pada suatu negara kita tersedia mata uang : dolar (100
sen), kuarter (25 sen), dim(10 sen), nikel(5 sen) dan peni(1 sen)
Masalah : Bagaimana menentukan algoritma untuk memeberikan uang kembalian dari suatu
pembayaran di super market dengan menggunakan sejumlah koin yang tersedia sekecil
mungkin
• Masalah : Ada seorang konsumen yan mempunyai uang kembalian sebesar 2.89 $ (289
sen) berapa coin yang harus di berikan oleh kasir ?
• Solusi : Kasir semestinya memberikan kembalian dengan 10 coin :

Nilai Uang (dalam sen) Nama

100 Dollar

25 Kuarter
10 Dim
5 Nikel
1 Peni
2 $ ,3 kuarter, 1 dim, 4 peni
80
 • Urutan pemberian adalah di mulai dari yang terbesar
Algoritma :
Function TukarKoin(n):himp koin
/*Buat kembalian n unit dengan kemungkinan jmlh koin paling sedikit
kontan C adalah jenis koin*/
Const C={100,25,10,5,1} /*kandidat yg di pilih*/
S atau {} /* S =himp solusi*/
S0 /* s jumlah dari item S*/
While sn do
x item terbesar dr C, dengan s+xn
if tidak ada item then return “solusi tidak ada”
SS {koin bernilai x}
ss+x
Return S

7.2. KARAKTERISTIK ALGORITMA GREEDY

- Himpunan kandidat.
Berisi elemen-elemen pembentuk solusi.
- Himpunan solusi
Berisi kandidat-kandidat yang terpilih sebagai solusi persoalan.
- Fungsi seleksi (selection function)
Memilih kandidat yang paling memungkinkan mencapai solusi optimal. Kandidat
yang sudah dipilih pada suatu langkah tidak pernah dipertimbangkan lagi pada
langkah selanjutnya.
- Fungsi kelayakan (feasible)
Memeriksa apakah suatu kandidat yang telah dipilih dapat memberikan solusi yang
layak, yakni kandidat tersebut bersama-sama dengan himpunan solusi yang sudah
terbentuk tidak melanggar kendala (constraints) yang ada. Kandidat yang layak
dimasukkan ke dalam himpunan solusi, sedangkan kandidat yang tidak layak dibuang
dan tidak pernah dipertimbangkan lagi.

81
 - Fungsi obyektif, yaitu fungsi yang memaksimumkan atau meminimumkan nilai solusi
(misalnya panjang lintasan, keuntungan, dan lain-lain).
Algoritma Greedy
procedure greedy(input C: himpunan_kandidat;
output S : himpunan_solusi)
{ menentukan solusi optimum dari persoalan optimasi dengan algoritma greedy
Masukan: himpunan kandidat C
Keluaran: himpunan solusi S
}
Deklarasi
x : kandidat;
Algoritma:
S{} { inisialisasi S dengan kosong }
while (belum SOLUSI(S)) and (C  {} ) do
xSELEKSI(C); { pilih sebuah kandidat dari C}
C C - {x} { elemen himpunan kandidat berkurang satu }
if LAYAK(S  {x}) then
SS  {x}
endif
endwhile
{SOLUSI(S) sudah diperoleh or C = {} }
algoritma greedy tidak beroperasi secara menyeluruh terhadap semua alternatif solusi yang
ada (sebagaimana pada metode exhaustive search). pemilihan fungsi SELEKSI: Mungkin
saja terdapat beberapa fungsi SELEKSI yang berbeda, sehingga kita harus memilih fungsi
yang tepat jika kita ingin algoritma bekerja dengan benar dan menghasilkan solusi yang benar-
benar optimum

82
7.3. IMPLEMENTASI AG
Implementasi Algoritma greedy banyak ragamnya, dalam modul ini yang akan di bahas
adalah Minimum Spanning Tree, yaitu Algoritma Kruskal dan Prim serta Shortest Path yaitu
algoritma Dijkstra.

7.3.1. REVIEW GRAPH

Kumpulan titik-titik dan garis-garis yang menghubungkan titik tersebut

Gambar 11. Graph : Titik : Node/vertex/simpul , Garis: edge

Setiap garis harus menghubungkan 2 titik yang berbeda, artinya tidak boleh ada cycle,
Titik boleh tidak dihubungkan dengan garis , Garis dapat berarah atau tidak berarah , Garis
dapat mempunyai bobot / value / nilai/ weight atau tidak berbobot , Graph dapat di sajikan
secara visual melalui diagram graph atau melalui matrix keterhubungan (adjecent matrix).

Graph dapat di representasikan dengan suatu larik/array atau linked list, jika dengan
larik dapat menggunakan matrik n2, dimana ada n baris dan n kolom, Baris dan kolom
berkaitan dengan setiap vertex/garis dalam graph, Jika ada vi ke vj maka barisnya adalah vi
dan kolomnya adalah vj ,Keterhubungan (adjencent) matriknya adalah adj[vi,vj]=1 jika (vi,vj)
adalah sebuah garis dalam graph, dan lainnya 0.Contoh Matrik keterhubungan (Adjacent
matrix).

83
 Gambar 12. Representasi Graph dalam Matrik keterhubungan

7.3.2. INDEGREE DAN OUTDEGREE

Indegree adalah suatu garis yang terhubung pada suatu graph yang di representasikan sebagai
matrik keterhubungan dalam kolomnya.

Outdegree adalah suatu garis yang terhubung pada suatu graph yang di representasikan
sebagai matrik keterhubungan dalam barisnya.

Contoh, Di ketahui suatu graph , Matriknya adalah

1 2 3 4 5 6

84
 1 0 0 0 0 0 0

2 1 0 0 1 0 0

3 0 1 0 0 0 1

4 0 0 1 0 1 1

5 1 0 0 0 0 0

6 1 1 0 0 1 0

Gambar 13. Persoalan Indegree dan Outdegree

Maka Indegreee dan outdegree yang di peroleh adalah

Indegree Outdegree
 Entri  Entri
Kolom Baris

1 3 0
2 2 2
3 1 2
4 1 3

5 2 1

6 2 3

Representasi graph dengan List adalah untuk meneglola setiap vertek dalam garis
keterhubungan dengan vertex tersebut di gambarkan sebagai :

85
 Gambar 14. Representasi Graph dengan List

Masalah: Bagaimana menghitung ID dan OD suatu node dalam graph dengan representasi adj
matrik.
Solusi :
• Baik Outdegree atau Indegree, Idenya dengan menggunakan sejumlah n sebagai index
kolom dan baris dalam adj matrik dan menghitung angka/nilai 1 dalam kolom dan
baris tersebut
• Misal nilai MAX=10 dan n2 adalah matrik
Sehingga yang harus kita lakukan adalah
- membuat suatu matrik keterhubungannya dulu
- Menentukan atau menghitung indegree
- Menentukan atau menghitung outdegree

86
Algoritma :

Latihan implementasi dalam bahasa c, Hitung OD dan ID dalam graph berikut

87
7.3.3. GRAPH TIDAK BERBOBOT
Dalam grap yang ti dak mempunyai bobot, artinya pada graph tersebut vertex atau garis
tidak mempunyai nilai atau bobot. Graph ini dapat berarah maupun tidak berarah. Entri dari
graph ini kalau di representasikan sebagai suatu matrik keterhubungan adalah sebagai berikut :

1 titik i, j terhubung langsung

aij  
0 titik tidak terhubung langsung
Misalkan di ketahui suatu graph sebagai berikut :

Dan jika di representasikan dalam suatu matrik keterhubungan maka di sajikan seperti matrik
di bawah ini :

88
 Gambar 15. Matrik Simetri

Terlihat matrik diatas berbentuk matrik simetri, artinya untuk graph tidak berarah akan
menghasilkan suatu matrik simetri, sedagnkan untuk graph berarah tidak menghasilkan matrik
simetri. Sekarang pehatikan gambar di bawah ini,

89
 A B C D E

A 0 1 0 1 0

B 0 0 1 1 0

C 0 1 0 0 1

D 1 0 0 0 0

E 0 0 0 1 0

Gambar 16. Representasi Graph dan matrik simetri

7.3.4. GRAPH BERBOBOT

Untuk graph berbobot, maka entri matriknya adalah sebagai berikut :

wij bobot titik i ke j jika terhubung langsung


aij   i dan j tidak terhubung sec ara langsung
0 jika i  j


Dan jika graph berbobot tersebut tidak berarah, maka matrik yang terbentuk adalah matrik
simetri, sedang untuk graph berbobot dan berarah maka matriknya tidak simetri. Perhatikan
contoh graph di bawah ini.

90
 A B C D E F

A 0 5    

B 5 0 2   

C  2 0 3 15 

D   3 0 8 

E   15 8 0 1

F     1 0

Gambar 17. Representasi Graph berbobot dalam matrik

7.3.5. PATH
Path adalah kumpulan garis dan titik yang dapat menghubungkan kedua titik tsb dengan
tidak ada garis atau titik yang di ulang kecuali titik awal dan akhir, jadi awal=akhir . Path
dapat di representasikan secara flowchart dan graph, perhatikan contoh di bawah ini :

Gambar 18. Representasi Graph dengan flowchart

91
Berdasarkan flowchart di atas maka path atau jalur dari A ke E adalah melalui
(1,4),(1,3),(2,5) dan (2,6), sehingga ada 4 jalur yang dapat di lalui dari titik A ke titik E. Bila
di representasikan dengan suatu graph maka path dapat di ilustrasikan sebagai berikut, missal
di ketahui suatu graph tidak berarah dan tidak berbobot seperti gambar berikut :

Gambar 19. Konversi flowchart ke Graph

Jalur yang mungkin dari A ke C adalah :

(A,B),(B,C) dan (A,B), (B,E),(E,D),(DC) sehingga terdapat dua jalur, sedangkan untuk jJalur
dari C ke G= (tidak ada/himpunan kosong)

7.3.6. CYCLE
Adalah path dari titik awal dan titik akhir yang sama dengan melalui minimum 1 titik lainnya,
contoh dari graph sebelumnya maka terdapat 2 cycle yaitu : A-B-E-A=1 cycle dan B-D-C-
B=1 cycle

7.3.7. GRAPH TERHUBUNG

Graph yang setiap pasang titik tidak ada path yang kosong (). Contoh sebelumnya
(A,B,C,…,G) adalah graph tidak terhubung, karena G tidak terhubung.

7.3.8. TREE
Adalah graph yang tidak berarah ,terhubung ,tidak mempunyai cycle,bisa berbobot atau tidak
berbobot tidak ada jalur yang tertutup. Perhatikan contoh di bawah ini.

92
 Gambar 20. Tree

7.4. MINIMUM SPANNING TREE (MST)

Adalah suatu tree yang di peroleh dari graph (terhubung dan berbobot) yang mempunyai
total bobot terkecil dan memuat semua tuitik dalam graph tersebut, Karena suatu tree maka
mst adalah graph tidak berarah, Total bobot adalah semua garis dalam tree yang terkecil.
Prinsip dalam MST adalah di peroleh dengan menghapus atau tidak menyertakan garis-garis
yang menyebabkan terjadinya cycle Lalu bagaimana menghapusnya ???. Solusi: garis yang di
hapus adalah garis yang berbobot besar sehingga yang tersisa adalah yang berbobot kecil .

7.4.1. ALGORITMA KRUSKAL

Ide dari algoritma ini adalah mengurutkan bobot pada edge mulai dari kecil ke besrl, lalu
mengambil garis-garis dengan bobot terkecil yang tidak menyebabkan terjadinya cycle dan
proses akan berhenti sampai semua titik sudah terhubung atau di peroleh Tree. Perhatikan
contoh di bawah ini.

Gambar 21. Tree Algoritma Kruskal

Perhatikan graph berbobot pada gambar a di atas, lalu pada gambar b edge pertama di
tambahkan atau di bentuk menjadi suatu tree yaitu (1,2) karena dia mempunyai bobot
93
minimum. Selanjutnya pada gambar c hingga e, edge-nya (1,3), (4,6) dan (5,6) di tambahkan
pada tree, lalu pada gambar f edge (2,3) membentuk suatu cycle dan oleh karena itu di
buang. Dengan cara yang sama gambar g edge (4,5) juga di buang. Akhirnya edge (3,4) di
tambahkan dan terbentuk MST (V, T) seperti di tunjukan gambar h.

Algoritma Kruskal
Input : Graph terhubung berbobot ddan tidak berarah, G =(V,E) dengan n vertek
Output: Himpunan edge T dengan MST untuk G

Urutkan edge dalam E dari kecil ke besar berdasarkan bobotnya

For v V
Buathimpunan ({v})
T={}
While |T|< n-1
Di berikan (x,y) menjadi edge dalam E
if Cari (x)  Cari(y) then
Tambah(x,y) ke T
Gabung(x,y)
Function Kruskal (G=<N,A>: graph;panjang:AR+):himp edge
/*inisialisasi*/
Sort A berdasarkan bobot terkecil
njum node dalam N
T /*berisi edge mst*/
Inisialkan himp n, masing2 berisi elemen yang berbeda dr N
/*greedy loop*/
Repeat
e{u,v}edge terpendek yg tdk di pertimbangkan
ucomptemukan(u)
vcomptemukan(v)
if ucompvcomp then
merge(ucomp,vcomp)
TT{e}
Until T berisi n-1 edge
Return T

94
Contoh Soal, Carilah MST dari graph berikut dengan algoritma kruskal

Gambar 22. Graph Persoalan MST

Garis yang W Titik terhubung

Keterangan
diambil tersortir yang di peroleh

BC 2 {B,C}

DF 2 {B,C} {D,F} BC dan DF tidak terhubung

AC 3 {A,B,C} {D,F} AC terhubung dengan BC

DH 3 {A,B,C} {D,F,H}

{A,B,C}
GE 3
{D,F,H}{G,E}

Karena CD terhubung dengan

CD 3 {A,B,C,D,F,H}{G,E}
ABC dan DFH

AE 4 {A,B,C,D,F,H,G,E}

95
Sehingga hasil akhir dari tree dari graph di atas adalah sebagai berikut :

Gambar 23. Hasil Graph Persoalan MST

Bagaimana jika garis CF pada graph sebelumnya bobotnya di ganti dengan 3 ?? maka akan di
peroleh tree dari graph baru seperti berikut :

Gambar 24. Graph Persoalan MST lainnya

Contoh Implementasi Algoritma potongan kode dalam C :

#define MaxV 10
#define MaxE 20
typedef enum {FALSE,TRUE} bool;

int getNVert(int edge[][3], int nedge) {

int nvert = −1; int j;
for( j=0; j<nedge; ++j ) {
if( edge[j][0] > nvert ) nvert = edge[j][0];
if( edge[j][1] > nvert ) nvert = edge[j][1]; }

96
return ++nvert;
}
bool isPresent(int edge[][3], int nedge, int v) {
int j;
for(j=0; j<nedge; ++j)
if(edge[j][2] < 0 && (edge[j][0] == v || edge[j][1] == v))
return TRUE;
return FALSE;
}
void kruskal(int edge[][3],int nedge)
int i,j,
tv1,tv2,tcost,
nspanedge=0,

nvert=getNVert(edge,nedge);
/*sortir edge*/
for(i=0;i<nedge-1;++i)
for(j=I;j<nedge;++j)
if(edge[i][2]>edge[j][2]){
tv1=edge[i][0];tv2=edge[i][1];tcost=edge[i][2];
edge[i][0]=edge[j][0];edge[i][1]=edge[j][1];
edge[i][2] = edge[j][2]; edge[j][0] = tv1;
edge[j][1] = tv2; edge[j][2] = tcost; }
for(j=0; j<nedge-1; ++j) {
int v1=edge[j][0];
int v2=edge[j][1];
/*cycle.*/
if(isAda(edge, nedge, v1) && isPresent(edge, nedge, v2))
printf(“ditolak:%d%d%d...\n ",edge[j][0],edge[j][1], edge[j][2]);
else {
edge[j][2] = -edge[j][2];
printf("%d %d %d.\n", edge[j][0], edge[j][1], -edge[j][2]);
if(++nspanedges == nvert-1) return; }
}
printf(“Tidak ada spanning tree utk graph.\n");
}

7.4.2. ALGORITMA PRIM

Idenya adalah mengambil garis-garis dengan bobot terkecil yang menghasilkan tree, dan
proses akan berhenti jika semua titik sudah masuk, Algoritma ini di mulai dari sembarang titik
dan mengambil garis yang berbobot kecil tetapi tetap mempertahankan sebagai tree.
Perhatikan contoh di bawah ini.

97
 Gambar 25. Graph Persoalan Prim

Berdasarkan gambar a pada grap di atas, vertek di sebelah kiri grais putus-putus milik X dan
yang kanan milik Y. Pertama-tama pada gambar a X={1} dan Y={2,3,…,6}. Gambar b
vertek 2 di pindahkan dari Y ke X karena edge (1,2) mempunyai cost terkecil yaitu 1. Hal ini
di indikasikan dengan berpindahnya garis putus-putus sehingga 1 dan 2 menjadi milik X atau
berada di kiri. Seperti di tunjukan pada gambar b kandidat vertek yang di pindahkan dari Y ke
X adalah 3 dan 4, karena edge (1,3) mempunyai cost terkecil di antar edge yang berakir di X
dan Y, 3 di pindahkan dari Y ke X. Selanjutnya dari dua kandidat vertek 4 dan 5 dalam
gambar c, 4 di pindah karena edge (3,4) mempunyai cost terkecil. Akhirnya vertek 6 dan
kemudian 5 di pindahkan dari Y ke X seperti di tunjukan pada gambar e. Setiap kali vertek y
di gerakan dari Y ke X, adalah merupakan edge yang terhubung di dalam T dan menghasilkan
MST seperti di tunjukan pada gamabar f.

Algoritma Prim

Di berikan Graph G=(V,E), dimana V adalah {1,2,3,….,n}. algoritma di mulai dengan

membuat 2 himpunan vertek X={1} dan Y={2,3,…,n}. Pada setiap langkah di cari edge

98
(x,y) dengan bobot minimum, dimana x  X dan y  Y lalu di pindahkan y adri Y ke X.
Edge ini di tambahkan pada MST saat ini pada T. Langkah ini di ulang hingga Y kosong.

T{};X{1};YV{1}
While Y{}
Di berikan (x,y) bobot minimum sedemikian rupa sehingga xX dan yY
XX{y}
YY-{y}
TT{(x,y)}

Function Prim(G=<N,A>):himp edge

/*inisialisasi*/
T
B{sebarang anggota N}
While BN do
cari e={u,v} dari bobot min sedemikian rupa shg uB dan v N/B
TT{e}
BB {v}
Return T

Berikut ini di berikan potongan kode dalam pascal mengenai algoritma Prim :

procedure Prim ( C: array[l..n, 1..n] of real );

{ Prim mencetak edge dg cost mst utk suatu graph
dg vertek {1, 2, . . . , n} dan matrik cost C utk setiap edge-ny }
var
LOWCOST: array[1..n] of real;
CLOSEST: array[1..n] of integer;
i, j, k, min; integer;
{ i dan j mrp index. Selama scanning dlm larik LOWCOST ,
k adl index vertek terdekat yang di temukan, dan min = LOWCOST[k] }
begin
for i := 2 to n do begin
{ init dengan hanya vertex 1 dalam himpunan U }
LOWCOST[i] := C[1, i];
CLOSEST[i] := 1
end;
for i := 2 to n do begin
{ cari vertek terdekat di luar k dari U ke suatu vertex dalam U }
min := LOWCOST[2];
k := 2;
for j := 3 to n do
if LOWCOST[j] < min then begin
min := LOWCOST[j];
k := j
end;
writeln(k, CLOSEST[k]); { cetak edge }
LOWCOST[k] := infinity; { k di tambahkan ke U }
99
 for j := 2 to n do { sesuaikan cost ke U }
if (C[k, j] < LOWCOST[j]) and (LOWCOST[j] < infinity) then begin
LOWCOST[j] := C[k, j];
CLOSEST[j] := k
end
end
end; { Prim }

Contoh Soal : Di ketahui suatu graph seperti di bawah ini, buatlah matrik keterhubungan dan
Tabel MST dengan algoritma Prim, lalu gambarkan tree dari graph yang di hasilkan.

Gambar 26. Graph MST Prim

Graph Asal

Sisi/garis S/garis
Langkah B
Terpilih/diambil Minimal yang dihasilkan

Inisiasi - {} {1} source

1 (1,5) {(1.5)} {1,5}
2 (1,3) {(1,3), (1,5)} {1,3,5}
3 (2,3) {(1,3), (1,5), (2,3)} {1,2,3,5}
4 (3,4) {(1,3), (1,5), (2,3), (3,4) } {1,2,3,4,5}
Tabel MST dengan algoritma Prim

Gambar 27. Tree terbentuk Graph Asal

100
Contoh lainnya,

Gambar 28. Graph Asal

Garis yang Titik terhubung yang di

Step W ket
diambil peroleh

1 - - {E} Init awal pada titik E

2 GE 3 {G,C} Diambil berdasarkan titik yang
terhubung pada saat init awal
3 EF 4 {G,E,C}
4 DF 2 {D,G,E,C}
5 CF 3 {C,D,E,F,G}
6 BC 2 {B,C,D,E,F,G}
7 AC 3 {A,B,C,D,E,F,G}
8 DH 3 {A,B,C,D,E,F,G,H}
Tabel MST dengan Algoritma Prim

Gambar 29. Graph terbentu (Tree)

101
7.4.3. SHORTEST PATH : ALGORITMA DIJKSTRA
Diketahui G=<N,A>, dimana N sejumlah titik/node dan A adalah himpunan garis berarah,
setiap garis tidak bernilai negatif. Salah satu node/titip di disain sebagai source node. Masalah
: Bagaimana menentukan panjang jalur terdekat dari source node ke tiap-tiap node dalam G
tersebut. Pemecahan masalah tadi dapat menggunakan AD (Algoritma Dijkstra). Algoritma
ini menggunakan 2 himp node yaitu S dan C. Pada himp. S berisi node yang terpilih yang
memiliki jarak minimal dari source. Pada himp. C berisi node selain yang terpilih dalam S,
yang belum di ketahui dan merupakan kandidat yang akan di pilih pada langkah berikutnya.
Dengan demikian kita akan peroleh N=SC . Pada saat algoritma berhenti, S berisi seluruh
node dari G dan masalah terselesaikan. Tiap langkah yang terpilih dalam C merupakan jarak
terkecil pad source dan di tambahkan ke S .

Algoritma Dijkstra

procedure Dijkstra;
{ Dijkstra menghitung cost shortest path dr
vertex 1 ke tiap vertex dr directed graph }
begin
(1) S := {1};
(2) for i := 2 to n do
(3) D[i] := C[1, i]; { inisialkan D }
(4) for i := 1 to n-1 do begin
(5) Pilih vertex w dlm V-S sedemikian sehingga D[w] adlh minimum;
(6) Tambahkan w ke S;
(7) for tiap vertex v dlm V-S do
(8) D[v] := min(D[v], D[w] + C[w, v])
end
end; { Dijkstra }
Contoh, diketahui graph sebagai berikut, Gunakan Algoritma Dijkstra

Gambar 30. Graph Dijkstran

102
Cari Source Ke Akhir simpul, ternyata ada:
1-2,1-3,1-4,1-5
Cari jalur terpendek dari tiap-tiap simpul yang berhubungan dr source ke akhir
 1-2
 1-2 =50
 1-3-4-2 =45, terpendek
 1-5-4-2 =95
 1-3
 1-3 =10
 1-2-3 =65, terpendek
 1-2-5-4-2-3 =125
 1-5-4-2-3 =110
 1-4
 1-3-4 =25, terpendek
 1-2-5-4 =90
 1-2-3-4 =80
 1-5-4 =75
 1-5
 1-5 =45,terpendek
 1-2-5 =60
 1-3-4-2-5 =65
 1-3-4-5 =60
Kumpulkan jalur terpendek dari masing-masing simpul yang berhubungan dr source ke akhir,
dan hasilnya adalah sebagai berikut :

Jalur Jarak

1-3 10

1-3-4 25

1-3-4-2 45

1-5 45

Gambar 31. Graph Penyelesaian Dijstra

103
7.4.4. SHORTEST PATH : ALGORITMA KNAPSACK
Ada beberapa versi dari masalah klasik ini. Salah satunya bisa diilustrasikan sebagai berikut.
Diberikan n objek dan sebuah ransel (knapsack). Masing-masing objek i mempunyai berat wi dan vi.
Ransel tersebut bisa memuat objek maksimal seberat W. Masalah yang harus dipecahkan adalah
bagaimana mengisi ransel dengan objek yang nilai maksimal tanpa melewati batas kapasitas dari
ransel. Dalam versi ini, diasumsikan bahwa masing-masing objek dapat dibagi menjadi bagian yang
lebih kecil, sehingga kita dapat memutuskan untuk hanya membawa sebagian objek i sebanyak x 1.
Dengan demikian, algoritma untuk masalah ini dapat disusun sebagai berikut, n adalah jumlah objek
wi adalah variabel yang menyatakan berat dari objek i, vi adalah variabel yang menyatakan nilai dari
objek i, xi adalah pecahan yang menyatakan beberapa bagian dari objek i yang dimasukkan dalam
ransel. Variabel berat menyatakan jumlah berat objek yagn sudah dimasukkan dalam ransel, sedangkan
W adalah kapasitas dari ransel.

7.4.4.1. SECARA MATEMATIS

Secara matematis maka terdapat property sebagai berikut :
• Fungsi Utama/Tujuan/Objektif
– Fungsi yg mjd penyelesaian masalah dengan mendapatkan solusi optimal, yaitu
mendapatkan nilai profit yg maksimal utk sejumlah obyek yang akan di muat
dalam ransel yg sesuai kapasitasnya
• Fungsi Pembatas/Subyektif
– Bertujuan memberikan batas maksimal setiap obyek untuk di muatkan dalam
ransel sesuai kapasitasnya
Dengan rumusan :

104
7.4.4.2. SECARA GREEDY
Sedangkan secara greedy permasalahan knapsack dapat di selesaikan dengan cara sebagai
berikut :

• Pilih obyek dengan nilai Pi maksimal

• Pilih obyek dengan bobot Wi minimal

• Pilih obyek dengan perbandingan Pi/Wi terbesar

Algoritma Greedy Knapsack

Procedure Gknapsack(P,W,x,n)
Real P(1:n),W(1:n),x(1:n),M,Isi;
Integer I,n;
X(1:1)0;
IsiM;
For i1 to n do
if W(i)>cu then exit
x(i)1
isiisi-W(i)
Repeat
if i<= n then x(i)isi/W(i)

Algoritma diatas dapat di tulis dengan pseudo code sebagai berikut,

– Inisiasi
• Untuk setiap i, set xi = 0
• Set berat = 0
– Selama berat < W lakukan
• Pilih i, yaitu objek yang paling potensial (lihat keterangan di bawah) dari objek yang
tersisa.
• Jika berat + wi ≤ maka
xi = 1
Berat = berat + wi
Jika tidak maka
xi = (W – berat) / wi
berat = W
Contoh,
Diketahui
n=3 dengan Wi(18,15,10) dan Pi(25,24,15) dan M=20, Ditanyakan : Tentukan berat tiap-
tiap barang yang dpt di muat dalam ransel dengan kapasitas M ?

105
Solusi dengan Matematis
Step 1
• Tentukan solusi feasibel yaitu 2 X n dari batas bawah dan atas, lalu hitung sesuai
kapasitas M<=20, untuk masing masing bobotnya

Step 2

• Buat tabel Untuk solusi fisibel

PiXi
Solusi ke (X1,X2,X3) WiXi
Profit

1 (0,1,1/2) 20 31.5

2 (1,0,1/5) 20 28

3 (1,2/15,1) 20 28.2

4 (0,2/3,1) 20 31

5 (5/18,1,0) 20 30.9

6 (5/9,0,1) 20 28.8

Solusi dengan Metode Greedy

106
 • Pilih barang dengan nilai profit Maksimal
– P1=25  x1=1, batas atas fungsi
– P2=24  x2=2/15, hasil perhit. fungsi pembatas
– P3=15  x3=0, batas bawah fungsi
• Pilih barang dengan berat Minimal
– W1=18  x1=0, batas bawah fungsi
– W2=15  x2=2/3, hasil perhit. fungsi pembatas
– W3=10  x3=1, batas atas fungsi
• Hitung Wi/Pi
– P1/W1=25/18  karena terkecil, maka x1=0, batas bawah fungsi
– P2/W2=24/15  karena terbesar, maka x2=1, batas atas fungsi
– P3/W3=15/10  di hit dengan F pembatas x3=1/2
• Buat Tabel

Solusi ke (X1,X2,X3) WiXi PiXi

Profit

Pi max (1,2/15,0) 20 28.2

Wi min (1,2/3,1) 20 31

Pi/Wi (0,1,1/2) 20 31.5

Solusi dengan Algoritma Greedy

Sorting Descending thd Pi/Wi

P1/W1=25/18 =1.39  urutan 3
P2/W2=24/15 =1.60  urutan 1
P3/W3=15/10 =1.50  urutan 2
Sehingga di peroleh
W1,W2,W3  15,10,18 dan P1,P2,P3  24,15,25

Running Algorithm
107
 • Di Inputkan ke algo Knapsak Greedy
X(1:n)0
Isi20
Mulai iterasi
i=1
W(i)>isi ?  15>20, tidak, maka
x(1)1, brg dpt dimuat seluruhnya dari W(1)=15
isi=20-15, kapasitas ransel berkuran mjd 5
i=2
W(2)>isi ?  5>10, ya, maka
x(2)5/10=1/2, brg dpt dimuat sebanyak ½ bagian saja dari W(2)=10
isi=5-5, kapasitas ransel habis
i=3, X(3)=0, isi=0, selesai, karena isi=0
• Menghitung Profit (P1+P2+P3)=(24.1+15.1/2+18.0)=31.5

108
 BAB VIII
ALGORITMA DIVIDE AND CONQUER

8.1. DEFINISI
Metode yang lain yang di bahas adalah algoritma Divide and Conquer, dimana algoritma
ini terdiri dari 3 bagian yaitu :

• 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), dan
• Combine: mengabungkan solusi masing-masing upa-masalah sehingga membentuk
solusi masalah semula.

Algoritma Divide And Conquer

procedure DIVIDE_and_CONQUER(input n : integer)

{ Menyelesaikan masalah dengan algoritma D-and-C.
Masukan: masukan yang berukuran n
Keluaran: solusi dari masalah semula
}
Deklarasi
r, k : integer
Algoritma
if n  n0 then {ukuran masalah sudah cukup kecil }
SOLVE upa-masalah yang berukuran n ini
else
Bagi menjadi r upa-masalah, masing-masing berukuran n/k
for masing-masing dari r upa-masalah do
DIVIDE_and_CONQUER(n/k)
endfor
COMBINE solusi dari r upa-masalah menjadi solusi masalah semula }
endif

109
versi lain

Procedure DNC(p,q)
Global n,A(1:n);integer m,p,q
If small (p,q) then G(p,q) else
M devide(p,q)
Combine(dnc(p,m),dnc(m+1,q))

Secara tradisional, rutin di dalam text algoritma ini terdiri dari setidaknya dua
pemanggilan rekursif yang di sebut algoritma divide dan conquer. Umumnya kita akan pecah
masalah menjadi sub masalah yang disjoint (unik/atomik), perhatikan diagaram di bawah.

Gambar 32. Ruang solusi DANDC

110
Solusi rekursif untuk masalah dengan n banyak dan pembagian n/2 masalah untuk solusi
semua masalah dapat di berikan algoritmanya sebagai berikut :

procedure DIVIDE_and_CONQUER(input n : integer)

{ Menyelesaikan masalah dengan algoritma D-and-C.
Masukan: masukan yang berukuran n
Keluaran: solusi dari masalah semula
}
Deklarasi
r, k : integer
Algoritma
if n  n0 then {ukuran masalah sudah cukup kecil }
SOLVE upa-masalah yang berukuran n ini
else
Bagi menjadi 2 upa-masalah, masing-masing berukuran n/2
DIVIDE_and_CONQUER(upa-masalah pertama yang berukuran n/2)
DIVIDE_and_CONQUER(upa-masalah kedua yang berukuran n/2)
COMBINE solusi dari 2 upa-masalah
endif

Dengan kompleksitas waktu sebagai berikut

 g (n) , n  n0
T (n)  
2T ( n / 2)  f ( n ) , n  n0
8.2. RUNNING TIME DARI ALGORITMA DIVIDE DAN CONQUER
Semua algoritma divide dan conquer yang efisien akan kita lihat dengan membagi masalah
menjadi sub masalah, dimana tiap pemecahan masalah dari masalah sesungguhnya, dan
kemudian melakukan perkerjaan tambahan untuk menghitung jawaban akhirnya. Sebagai
contoh kita akan menganalisa operasi yang di lakukan dalam merge sort dengan memecah
menjadi dua sub masalah, dimana setengah masalahnya merupakan besar dari ukuran
sebenarnya dan menggunakan pekerjaan tambahan dengan memakai O(n). Sehingga
persamaan waktu tempuhnya, dengan inisial kondisi, adalah

111
T(n) = 2T(n/2) + O(n)
Dan solusi persamaan di atas berada dalam order O(n log n). Dengan menggunakan teorema
di bawah ini kita dapat menentukan waktu tempuh algoritma divide dan conquer.
Solusi persamaan T(n) = aT(n/b) + Θ(nk), dimana a 1 dan b > 1, adalah

 O ( n log b a ) if a  bk

T ( n )  O ( n k log) if a  bk
 O (n k ) if a  bk
Contoh : 

Masalah menentukan Max dan Min dari n data :

MaxMin dengan metode biasa → g(n)= 2n-1

MaxMin dengan metode devide and conquer → g(n)=

Rekursif conquer

Contoh Masalah : Mencari g(n) dengan DANDC, n adalah power of 2

112
 n g(n)
2 1
4 2g(2)+2 = 4
8 2.4+2 = 10
16 2.10+2 = 22
32 2.22+2 = 46
64 2.46+2 = 94
n n−2

Masalah : Algoritma Perkalian 2 Bilangan Besar n Digit

Misal n=4
x = 6789
y = 2476 x
z = ......... ?
Problem Size = n
Operasi Dominan = perkalian
algoritma biasa g(n) = n2 + cn → O(n2)
Solusi deengan metode DANDC adalah

a=67 b=89 x=67*102 + 89 = a.10n/2 + b

c=24 d=76 y=24*102 = 76 = c.10n/2 + d
z = ....
z = x.y = (a.10n/2 + b).(c.10n/2 + d)
z = ac.10n + (ad+bc) 10n/2 + bd
g(n) = 4g( ) + cn → O(n2) →berdasarkan teorema
5 kali rekursif (ac, ad, bc, bd) perhatikan tabel berikut

113
 X a b
Y c d
O(n2) tidak berubah menjadi lebih efisien, maka conquer perlu diubah
pseudo code
Begin
u ← (a+b).(c+d)
v ← ac
w← bd
z ← v.10n + (u–v−w) 10n/2 + w
End
maka g(n)= 3g( ) + cn → O(nlog 3) = O(n1,59)

8.3. TEOREMA MENCARI O(F(N)) UNTUK METODE D AND C

8.4. ALGORITMA SORTING

Mengurutkan data dilihat dari struktur data dapat di bagi menjadi dua bagian yaitu statis
(larik/array) dan dinamis (pointer). Dari dua macam cara penyimpanan data tersebut masing-
masing mempunyai keuntungan dan kerugian baik dalam hal kecepatan, efisiensi dan aspek
kapasitas memori.

8.4.1 INSERTION SORT

Idenya seperti pemain kartu yang membagi elemen menjadi 2 kelompok, yaitu kelompok
kartu yang terurut berada di tangan pemain, dan kelompok kartu sumber yang akan diambil
untuk disisipkan secara urut ke dalam kelompok kartu pertama. Dibawah ini psuedocode dari
Insertion sort.

114
INSERTION-SORT (A)
1 for j  2 to length[A]
2 do key  A[j]
3 { Sisipkan A[j] ke dalam urutan terurut A[1 . . j - 1].}
4 ij-1
5 while i > 0 and A[i] > key
6 do A[i + 1] A[i]
7 ii-1
8 A[i + 1] key

Algoritma di atas dalam bentuk suatu prosedur dengan nama INSERTION-SORT, dengan
parameter berupa larik A[1 . . n] yang berisi urutan larik sepangjang n (length[A) yang akan di
urutkan. Perhatikan contoh berikut pada suatu larik 5,2,4,6,1,3 yang akan di urutkan:

Gambar 33. Langkah sortir

Gambar di atas menunukan cara kerja algoritma untuk larik A = 5, 2, 4, 6, 1, 3. Indek j

mengindikasikan "kartu yang di pegang saat ini" yang akan di sisipkan kedalam kumpulan
kartu yang di tangan. Elemen larik A[1.. j - 1] menunjukan kartu yang sudah terurut di tangan
sedangkanelemen A[j + 1 . . n] merupakan tumpukan kartu yang masih ada di meja. Index j
bergereak dari kirir ke kanan dalam larik. Tiap iterasi pada for loop terluar, elemen A[j] di
ambil dari latik (baris 2). Kemudian mulai dari posisi j - 1, elemen secara berturut-turut de
gerakan satu posisi ke akanan hingga posisi yang tepat untuk A[j] di temukan (baris 4-7),
setelah itu disispkan (baris 8). Kompleksitas dari algoritma ini berada dalam order O(n2).

115
Analisa Insertion Sort

INSERTION-SORT (A) cost time

for j  2 to length[A] c1 n
do key  A[j]3 c2 n-1
{ Sisipkan A[j] ke dalam urutan terurut A[1 . . j - 1].} 0 n-1
ij–1 c4 n-1
while i > 0 and A[i] > key c5
do A[i + 1] A[i] c6
ii–1 c7

A[i + 1] key c8 n-1

8.4.2 SELECTION SORT

Idenya adalah mencari membandingkan data dengan data lain yang terkecil kemudian
menukar posisinya (index-nya), hal tersebut dilakukan urut mulai dari index terkecil hingga
habis.

Algoritma Selection Sort 1

selectionsort(int A[], int besararray){

int i, j;

116
int min, temp;
for (i = 0; i < besararray -1; i++){
min = i;
for (j = i+1; j < besararray; j++){
if (A[j] < A[min]) min = j;
}
temp = A[i]; /*pertukaran data*/
A[i] = A[min];
A[min] = temp;
}
}
Algoritma Selection Sort 2

var lowkey: keytype;

{ kunci terkecil yg ada dari larik A[i], . . . , A[n] }
lowindex : integer; { posisi lowkey (kunci terkecil)}
begin
1. for i := 1 to n-1 do begin
{ pilih data terendah dr A[i],. . , A[n] dan di tukar dg A[i] }
2. lowindex := i;
3. lowkey := A[i].key;
4. for j := i + 1 to n do {bandingkan key dg lowkey }
5. if A[j].key < lowkey then begin
6. lowkey := A[j].key;
7. lowindex := j end;
8. swap(A[i], A[lowindex])
end
end;

Analisa Selection Sort

117
Dari Inner Loop di daptkan
(akhir – awal + 2) + (akhir – awal + 1) (p + 1))
= ((n – (i+1)) + 2) + ((n – (i+1)) + 1) (2 + 1)
= ((n – (i+1)) + 2) + ((n – (i+1)) + 1) . 3
= ((n – (i+1)) + 2) + 3(n – (i+1)) + 3
= 4 (n – (i+1)) + 5
= 4n – 4i +4+5
= 4n – 4i +9
(P(i)) = Banyak Langkah dalam S = 1 + banyak langkah inner loop
= 1 + 4n – 4i +9
= 4n – 4i +10

8.4.3 BUBBLE SORT

Metode pengurutan gelembung atau penukaran dapat dilakukan dengan meletakkan
elemen terbesar pada sebelah paling kanan urutan (N) dan kemudian elemen terbesar kedua
diletakkan pada posisi N-1, begitu seterusnya. Atau sebaliknya dengan mencari elemen
terkecilnya diletakkan paling kiri (pertama/i), dan terkecil kedua di i+1 dan seterusnya.
Bubble sorting merupakan teknik pengururtan sederhana dimana kita akan mengurutkan
elemen dalam suatu daftar dengan membentuk pasangan elemen yang terhubung berdekatan.
Artinya kita akan bentuk pasangan elemen ke-i dan i+1. Jika urutan berbentuk ascending, kita
akan pertukarkan pasangan elemen jika elemen pertama pada pasangan lebi besar dari yang
kedua. Artinya setiap pasangan dalam list/array A, (A[i],A[i+1]) for i:=1 to (n−1) jika A[i] >
A[i+1], kita pertukarkan A[i] dan A[i+1]. Hal ini kita lakukan hingga pada posisi ke-n, yang
merupakan besar larik/list. Dengan demikian kita akan mengulang proses pada tiap iterasi
118
dengan elemen dari posisi pertama hingga posisi (n−1). Hal ini akan member nilai tertinggi
dari posisi sisa nilai (n−1) hingga (n−1). Kita ulangi lagi proses ini dari sisa nilai (n−2) begitu
seterusnya. Hingga kita dapatkan data terurut. Dalam kasus ini kita memerlukan pengiriman
sebesar (n−1) pada pasangan pertama, lalu (n−2) untuk pasangan kedua dan yang terakhir
adalah hanya satu pengiriman (n−1), secara matematis dapat di tulis,
=(n-1)+(n-2)+(n-3)+…+1 = n(n-1)/2
Sehingga algoritma ini berada pada order O(n2)
Algoritma Bubble Sort

procedure sort(var r : ArrayToSort; lo, up : integer);

var i, j : integer, tempr : ArrayEntry;
begin
while up>lo do begin
j := lo;
for i:=lo to up— 1 do
if r[i].k> r[i+l].k then begin
tempr := r[i];
r[i] := r[t+l];
r[i+l] := tempr,
j := i
end;
up := j
end
end;

atau dalam c dapat di tulis dengan,

void bsort(int list[], int n)
{
int i,j;
for(i=0;i<(n-1);i++)
for(j=0;j<(n-(i+1));j++)
if(list[j] < list[j+1])
swap(&list[j],&list[j+1]);
}

8.4.4 SEQUENTIAL SORT

Mengurutkan Data secara sekuen, baik dari kecil ke besar ataupun besar ke kecil,
membanding current dengan next , Jika current > next, maka tukarkan, hal tersebut dilakukan
hingga data berada pada posisi terakhir atau habis . Kompleksitas waktu pada algoritma ini

119
berada pada order O(n2). Untuk data berukuran kecil maka algoritma ini berjalan relative
stabil sedangkan untuk data besar maka menjadi tidak stabil.
Algoritma Sequential Sort
Seq(int *x, int n){
int i,j,temp;
for (i=0;i<n-1;i++)
for (j=i+1;j<n;j++)
if (x[i]>x[j]) {
temp=x[i];
x[i]=x[j];
x[j]=temp;
}
}
Untuk data seperti di bawah ini, maka:
x= 2, 1, 6, 7, 4, 3, 2
i= 1 2 3 4 5 6 7
j= 2 3 4 5 6 7

Data SEBELUM diurutkan

2167432
i:0
j=1-> 1 2 6 7 4 3 2
j=2-> tidak berubah
j=3-> tidak berubah
j=4-> tidak berubah
j=5-> tidak berubah
j=6-> tidak berubah
i:1
j=2-> tidak berubah
j=3-> tidak berubah
j=4-> tidak berubah
j=5-> tidak berubah
j=6-> tidak berubah
i:2
j=3-> tidak berubah
j=4-> 1 2 4 7 6 3 2
j=5-> 1 2 3 7 6 4 2
j=6-> 1 2 2 7 6 4 3
i:3
j=4-> 1 2 2 6 7 4 3
j=5-> 1 2 2 4 7 6 3
j=6-> 1 2 2 3 7 6 4
i:4
j=5-> 1 2 2 3 6 7 4
120
j=6-> 1 2 2 3 4 7 6
i:5
j=6-> 1 2 2 3 4 6 7

Data SETELAH diurutkan

1223467

8.4.5 MERGE SORT

Mergesort berjalan dalam kompleksitas waktu worst case O(n log n) , dan jumlah
perbandingan yang di pakai mendekati optimal. OPerasi dasar dalam algoritma ini adalah
melakukan merge dari dua list tersortir. Karena list sudah tersortir, hal ini dapat di selesaikan
dalam pengiriman suatu input, artinya dua list tadi setelah di merge akan menghasilkan output
yaitu list ke tiga. Dasar-dasar algoritma merge adalah mengambil 2 input array a dan b, dan
output array c, serta 3 konstan katakan, aptr, bptr, dan cptr, yang menginisialisasikan
himpunan awal untuk array tersebut. Untuk [aptr] yang lebih kecil dan b[bptr] di kopi ke entri
selanjutnya pada entri c. Saat kedua input dalam list sudah terpenuhi, sisanya berupa list lain
yang sudah di kopikan ke c. sontoh di bawah ini menunjukan cara kerja algoritma merge.
Misal ada suatu array a berisi 1, 13, 24, 26, dan b berisi 2, 15, 27, 38, maka algoritma
memproses kedua array tersebut menjadi, pertama, lakukan perbandingan antara 1 dan 2,
hasilnya 1 di tambahkan ke c, lalu 13 dan 2 di bandingkan hasilnya 2 di tambahkan ke c. 13
dan 15 di bandingkan dan hasilnya 13 di simpan di c.

Kemudian 24 dan 15 di bandingkan, begitu seterusnya hingga 26 dan 27 di bandingkan, dan

setelah mencapai penambahan 26 pada c maka array a sudah habis.

121
Sisanya adalah larik b, yang akan di tambahkan ke c

Gambar 35. Pointer

Jelas waktu untuk melakukan merge dari dua list tersortir adalah linear, karena kebanyakan
perbandingan di lakukan sebanyak n - 1, dimana n adalah total jumlah elemen. Algoritma
mergesort di jelaskan sebagai berikut. Jika n = 1, hanya ada satu elemen yang di sortir, selain
itu , mergesort secara rekusrsif, setengah pertama dan setengah kedua. Hal ini memberikan
separoh dua larik tersortir, yang dapat di merge bersama-sama menggunakan algoritma merge
sort tadi. Sebagai contoh untuk mengurutkan empat elemen larik 24, 13, 26, 1, 2, 27, 38, 15,
kita lakukan pengurutan secara rekursif pada ke empat pertama dan teakhir dari elemen
tersebut, sehingga di dapatkan 1, 13, 24, 26, 2, 15, 27, 38. Lalu kita merge setengah pertama
dan kedua sehingga di peroleh hasil akhir 1, 2, 13, 15, 24, 26, 27, 38. Jelas masalahnya adalah
membagi (divided) kedalam masalah yang lebih kecil dan menyelesaikan secara rekursif.
Algoritma Mergesort 1 dalam c

void merge(int X[],int l,int m,int n,int Z[]){

int i,j,k;
i=k=l;
j=m+1;
while( i <= m && j <= n){
if(X[i] <= X[j]) {Z[k] = X[i];i++;}
else{Z[k] = X[j];j++;}
k++;
}
if (i>m){
/*Zk...Zn <-- Xj...Xn*/
while(k<=n && j<=n){Z[k] = X[j];k++;j++}
}else {
/*Zk...Zn <-- Xi...Xm*/
while(k<=n && i<=m){Z[k] = X[i];k++;i++;}
}
}

void mpass( int X[],int Y[],int n,int l){

int i;
i = 0;
while( i <= (n-2*l+1)){merge(X,i,(i+l-1),(i+2*l-1),Y);i = i + 2*l; }

122
 if((i+l-1) < n) merge(X,i,(i+l-1),n,Y); else
while (i <= n ){Y[i] = X[i];i++; }
}

void msort(int X[], int n )

{
int l; int Y[MAX];
l =1;
while (l < n ){
mpass(X,Y,n,l);
l = l*2;
mpass(Y,X,n,l);
l = l*2;
}
}

Algoritma merge sort untuk 2 larik dalam c

void mergesort(int numbers[], int temp[], int array_size){
m_sort(numbers, temp, 0, array_size - 1);
}

void m_sort(int numbers[], int temp[], int left, int right){

int mid;
if (right > left)
{
mid = (right + left) / 2;
m_sort(numbers, temp, left, mid);
m_sort(numbers, temp, mid+1, right);
merge(numbers, temp, left, mid+1, right);
}
}

void merge(int numbers[], int temp[], int left, int mid, int right){
int i, left_end, num_elements, tmp_pos;
left_end = mid - 1;
tmp_pos = left;
num_elements = right - left + 1;
while ((left <= left_end) && (mid <= right))
{
if (numbers[left] <= numbers[mid])
{
temp[tmp_pos] = numbers[left];
tmp_pos = tmp_pos + 1;
left = left +1;
}
else
{
temp[tmp_pos] = numbers[mid];
tmp_pos = tmp_pos + 1;
mid = mid + 1;
}
}

123
 while (left <= left_end)
{
temp[tmp_pos] = numbers[left];
left = left + 1;
tmp_pos = tmp_pos + 1;
}
while (mid <= right)
{
temp[tmp_pos] = numbers[mid];
mid = mid + 1;
tmp_pos = tmp_pos + 1;
}
for (i=0; i <= num_elements; i++)
{
numbers[right] = temp[right];
right = right - 1;
}
}
Analisa Merge Sort

Pada algoritma mergesort 1, tiap iterasi dalam loop while k dinaikan 1. Sehingga total
inkremen k adalah n - l + 1. Dengan demikian loop while di iterasi paling banyak n - l + 1
kali. Pernyataan if bergerak paling banyak satu elemen per iterasi. Waktu tempuhnya adalah
O(n - l + 1). Jika panjang elemen M maka waktunya O(M(n - l + 1)). Ketika M lebih besar dari
1 kita akan menggunakan array (X1, ...,Xm) dan (Xm+1, ...,Xn) sehingga di dapatkan array
tersortir baru yang berisi n - l + 1 elemen. Jadi sekarang kita tidak perlu ada tambahan space
untuk elemen n - l + 1 seperti yang di perlukan oleh array Z, dan hanya di butuhkan space
sebanyak n - l + 1. Sehingga hanya sebanyak n - l + 1 elemen saja yang di merge.

8.4.6 QUICK SORT

Seperti namanya, quicksort merupakan algoritma sorting yang tercepat dalam praktek.
Dalam waktu tempuh rata-rata dia berada pada order O(n log n). Hal tersebut sangatla cepat
terutama mempnyai optimasi yang tinggi pada inner loop. Pada worstcase order quicksort
berada dalam O(n2), tetapi ini dapat di buat secara eksponensial dengan sedikit usaha
(merubah rekuren ke iteratif). Algoritma ini mudah untuk di mengerti, jelas dia berada pada
jenis divide-and-conquer recursive algorithm. Dasar algoritmanya adalah mengururtkan larik
S yang terdiri dari 4 langkah :
1. Jika jumlah elemen dalam S adalah 0 atau 1, maka urutan sudah terjadi (trivial).
2. Ambil sembarang elemen v dalam S. Ini di sebut pivot.

124
3. Partition atau bagi S - {v} (sisa elemen dalam S) ke dalam dua kelompok yang berbeda :
S1 = {x S - {v}| x v}, dan S2 = {x S -{v}| x v}.
4. Kembalikan { quicksort(S1) di ikuti oleh v dan di ikuti lagi oleh quicksort(S2)}.
Misal, suatu array a[1],…..,a[n] akan diurutkan dengan memilih nilai dalam array tersebut
sebagai elemen kunci. Kemudian kita pertukarkan elemen pertama dalam list tersebut dengan
elemen kunci sehingga elemen kunci berada di awal larik. Lalu kita tentukan kunci tersebut ke
tempat yang semestinya dalam list. Tempat untuk kunci tersebut dalah salah satu dari banyak
elemen di sebelah kiri kunci yang lebih kecil nilainya dari kunci tersebut dan seluruh elemen
yang lebih besar dari kunci tersebut berada di sebelah kanannya.
Untuk mendapatkan kiunci pada posisi yagn tepat, kita lakukan traversal pada list di kedua
arah tersebut dengan menggunakan index i dan j. Kita menginisialkan I ke index yang lebih
besar satu dari index elemen kunci. Jika list yang akan di urutkan mempunyai indek yang
berjalan dari m ke n, maka elemen kunci berada pada index m, dengan demikian kita
menginisialisasikan i ke (m+1). Index i di inkremen hingga kita mendapatkan elemen pada
posisi ke-i yang lebih besar dari nilai kunci. Serupa dengan hal tadi kita juga
menginisialisasikan j ke n dan mendkremen j hingga kita dapatkan elemen dengan nilai yang
kurang dari nilai kunci tersebut.
Kita kemudian periksa apakah nilai i dan j saling melewati. Jika tidak, kita pertukarkan
elemen pada posisi key (ke-m) dengan elemen posisi ke j. Hal ini membawa elemen kunci ke
posisi ke-j dan kita akan menemukan elemen tersebut di kiri yang kurang darinya dan di
sebelah kanan yang lebih besar darinya. Maka dari itu kita akan pisah list menjadi dua sublist.
Sublist yang pertama merupakan gabungan dari elemen dari posisi ke-m hingga posisi (j–1),
dan yang kedua terdiri dari elemen pada posisi ke (j+1) hingga posisi ke-n. Lalu kita ulangi
langkah tersbut untuk setiap sublist secara terpisah. Kita memilih entri dalam list sebagai
kunci, dengan mencari median atau nilai tengah seperti di sebutkan di muka dengan mudah.
Dalam C dapat di lakukan dengan,
int posisikunci(int i,j)
{
return(( i+j )/ 2);
}
Atau dengan cara random
int posisikunci(int i,j)
{
125
 return(angka random dalam jangkauan i hingga j);
}

Algoritma quicksort dalam c

void qsort(int list[],int m,int n)
{
int key,i,j,k;
if( m < n)
{
k = posisikunci(m,n);
tukar(&list[m],&list[k]);
key = list[m];
i = m+1;
j = n;
while(i <= j)
{
while((i <= n) && (list[i] <= key))
i++;
while((j >= m) && (list[j] > key))
j-;
if( i < j)
tukar(&list[i],&list[j]);
}
tukar(&list[m],&list[j]);
qsort(list[],m,j-l);
qsort(list[],j+1,n);
}
}

8.5. ALGORITMA SEARCHING

Disadari atau tidak , setiap kali kita menjalankan komputer, hal pertama yang selalu
kita lakukan adalah mencari sesuatu, entah itu suatu file, folder atau alamat url tertentu.
Dengan demikian kebanyakan pekerjaan yang di lakukan di dalam komputer cenderung pada
mencari sesuatu sebelum melakukan sesuatu. Hal inilah mengapa algoritma searching menjadi
isu pokok dalam ilmu komputer, dan di bagian ini akan di coba mengurai algoritma terpilih
tersebut untuk di lakukan analisa.

8.5.1 SEQUENTIAL SEARH

Dikenal sebagai linear search, bagaimana mencari key(info yang dicari) pada suatu data tak
terurut hingga data dapat di temukan atau tidak di temukan dan mencapai sudah mencapai akhir larik
data. Dalam metode sekuensial ini perlu di ketahui lebih dahulu bagaimana cara menyimpan datanya,
flow chart algoritma ini dapat digambarkan sebagai berikut :

126
 Gambar 36. Flowchart insert Sequential

Mula-mula, (a) penyisipan di lakukan dengan menentukan alamat data awal dan memerikasa
apakah pada alamat tersebut terdapat suatu data atau tidak, jika tidak terdapat data, maka pada
alamat tersebut data akan di isikan. (b) Sebaliknya jika berisi suatu data, maka kita cukup
menginkremen/menaikan nilai alamat sebagai index sebanyak satu kali saja, lalu kita akan
periksa apakah pada alamat tersebut sudah mencapai akhir dari ketersedian alamat atau belum,
(c) jika sudah berada di luar space yang tersedia maka algoritma berhenti , jika tidak maka
akan mengulang langkah (a), begitu seterusnya hingga langkah (c) di temukan dan algoritma
berhenti.
Dalam metode pencarian sekuensial, perbandingan yang di lakukan adalah sebanyak n kali
dalam kasus worstcase, sehingga algoritma ini berorder O(n). Jika pada index i data ketemu
maka dia berada pada O(i). Sehingga rata-rata pencariannya berada pada O(n/2). Di bawah ini
akan di sajikan flowchar pencarian secara sekuensial.

127
 Gambar 37. Flowchart sekuensial search

Cara kerja algoritma ini, adalah pertama-tama (a), pencarian di awali dengan alamat awal dan
mengecek isi dari alamat tersebut mengenai keberadaan data. Apabila pada alamat tersebut
tidak berisi maka data tidak dapat di temukan dan algoritma berhenti, jika tidak (b)
makaagoritma akan memeriksa apakah pada alamat tersebut isi data sama dengan data yang di
cari, jika ya (c) maka data di temukan pada alamat tersebut dan algoritma berhenti, jika tidak
(d) kita akan memeriksa apakah data yang di cari nilainya lebih besar dengan nilai data pada
alamat tersebut atau tidak jika ya, maka (e), algoritma akan menginkremen index alamat
tersebut sebanyak 1 kali lalu kembali ke langkah (a). Namun jika ternyata nilai data tidak
memenuhi kondisi (d), maka data tidak di temukan dan algoritma berhenti. Di bawah ini akan
di berikan contoh pencarian secara sekensial.

128
 Gambar 38. Gambar peta memori

Misalkan ada data dalam suatu memori seperti gambar di atas, akan di cari data bernilai 50, maka
menurut algoritma searching akan berjalan sebagai berikut :
1. Addr=0, m(addr) isi data ? Y
2. M(addr)=data ?  T (15<>50)
3. M(addr)>data ? Y (50>15)
4. Addr=addr+1 (addr=1)
5. Ulangi langkah 1
Jika di jalankan maka akan memerlukan 5 langkah untuk menemukan data 50, yaitu dr
15,20,25,30 dan 50

129
8.5.2 BINARY SEARH
Pencarian secara biner atau di kenal sebagai binary search adalah merupakan pencarian
bagi dua yang masuk dalam kelompok algoritma DANDC. Ide algoritma ini cukup sederhana,
yaitu dengan memecah masalah pencarian menjadi dua, begitu seterusnya, hingga di temukan
data yang di inginkan. Pada algoritma ini dapat di representasikan dengan data linear atau
suatu tree (binary search tree). Syarat dari pencarian dalam algoritma ini adalah data sudah
harus terurut. Kita akan menelaah dari representasi data secara linear dan lalu secara non-
linear dengan memanfaatkan tree.
Misalkan di ketahui suatu data dalam larik x=x(1),x(2),x(3),…,x(n), dan kita akan mencari
data a dalam larik x tersebut sedemikian rupa sehingga apabila x[i]=a maka kita dapat ketahui
i. Secara umum rumusannya dapat di tuliskan dengan :

Algoritma akan memecah masalah (larik) menjadi 2 bagian berdasarkan nilai tengahnya, yang
di dapatkan dari nilai index akhir larik di kurangi nilai index awal larik di bagi dua. Pada hail
pembagian tersebut di dapatkan nilai index tengah (t) yang di jadikan perbandingan terhadap
data yang di cari, caranya dengan menentukan data pada alamat di t apakah lebih besar atau
lebih kecil. Jika lebih kecil maka larik atau n size problem tersebut di bagi dua lagi dengan
mengganti nilai index akhir larik menjadi nilai tengahnya, dan nilai tengah yang bari di
tentukan dengan cara yang sama seperti semula. Algoritma akan berhenti bila nilai index lebih
kecil dari nilai index awal atau lebih besar dari nilai index akhir. Dalam binary search, jumlah
perbandingan yang di perlukan untuk mencari satu elemen dalam list dalah tidak lebih dari

130
log2n, dimana n adalah ukuran list . Dengan demikian algoritma binary search mempunyai
kompleksitas waktu O(n *( log2n))
Ukuran efisiensi :
max=2log n mis n=16 maka 4 langkah

min=1

rata2=(1+2+…+log n) log n == ½ 2 log n

Algoritma binary search di berikan dalam bentuk notasi bahasa c dan flowchart sebagai berikut :

int BinSearch(int *arr, int val, int N)

{
int low = 0; int high = N – 1; int mid;
while ( low <= high ) {
mid = ( low + high )/2;
if (arr[mid]==val) {return 1; }
else if (arr[mid] < val) {
low = mid + 1;
}
else { high = mid – 1;}
}
return 0;
}

Gambar 39. Flowchart Binary Search

131
Contoh kasus:

Di ketahui larik x= 2 7 9 12 14 20 36 76 100 125

Dengan index i= 1 2 3 4 5 6 7 8 9 10

ingin dicari a=36 dalam x

jawab :
x= 2 7 9 12 14 20 36 76 100 125
i= 1 2 3 4 5 6 7 8 9 10
langkah 1.
lower=1 , upper=10 , t=(lower+upper) div 2 = 5 dengan x[5]=14 , Dicari a=36, sehingga
36>14,
langkah 2
karena a>x[t]  36>14, maka lower = (t+1)=6 , upper=10 ,dan t=16/2=8 dengan x[8]=76
langkah 3
karena a<x[8] 36<76, maka lower=6, upper=t-1=7, dan t=6 dengan x[6]=20
langkah 4
karena a>x[6] ,36>20, maka lower=t+1=6+1=7 , upper=7 , t=7 dengan x[7]=36 , ketemu

Jadi diperlukan 4 langkah pencarian dalan data linear dengan binary search.

8.5.3 INTERPOLATION SEARH

Dikenal sebagai estimated entry search, syarat data sudah terurut mirip Binary Search
tetapi lebih canggih sedikit (lihat flowchart). Pada tiap langkah pencarian algoritma membuat
suatu tebakan/perkiraan (Interpolasi), oleh karenanya di sebut sebagai interpolasi search.
Ketika n besar, binary search membutuhkan waktu lebih sedikit, dalam worst case, di banding
linear search. Hal ini karena di membuat perbandingan lg n dari pada n. Langkah yang di
tunjukan dalam binary search lebih kompleks dan membutuhkan waktu yang lebih dari pada
langkah dalam linear search. Dengan demikian untuk kasus n kecil, linear search lebih cepat.
Mirip dengan hal sebelumnya, interpolation perlu melakukan langkah kompleks dalam loop ,
walaupun dia memerlukan lebih sedikit waktu di banding binary search. Pada n yang besar
maka interpolasi lebih cepat di banding binary, karena pada saat melakukan interpolasi

132
terhadap penentuan median lebih presisi, walupun langkahnya lebih kompleks . Di bawah ini
di berikan flowchart pencarian secara interpolasi.

Gambar 40. Flowchart Interpolasi Search

Dan secara notasi bahasa dapat di berikan algoritmanya sebagai berikut :

int isearch(typekey key, dataarray r[]){

int high, j, low ;
low = 1; high = n;
while (r[high]>= key) && (key > r[low]) do{
j= trunc((key— r[low])/(r[high]— r{low])*(high—low))+low;
if (key>r[j]) low = j+1;
else if (key < r[j]) high := j-1
else low =j;
}
if (r[low]== key) return(low) /*** ketemu(r[low]) ***/
else return(—1); /*** tidakketemu ***/
}

Contoh kasus :

Data = 5,10,20,28,40,42,50,60,80,100,1000

Cari 100,800,13 dan 40 dengan Sekuensial, Binary dan Interpolation

133
 i 0 1 2 3 4 5 6 7 8 9 10

N 5 10 20 28 40 42 50 60 80 100 1000

N=11, P>N  0<=p1<=P-1

Jawab :

Sekuensial Search : 100,800,13,40

134
Binary Search: (1)100,(2)800,(3)13,(4)40

Data>M(addr) maka L=t+1 dan U tetap

Data<M(addr) maka L tetap dan U=t-1

Interpolasi Search

135
Perbandingan Metode

136
 BAB IX
ALGORITMA BASIS GRAPH
Dalam struktur data kita sudah pernah melakukan kunjungan dalam suatu list, yang mana
kita lakukan secara sekuensial dengan mencetak nilai dalam list tersebut. Dalam graph,
melakukan kunjungan atau traversal berarti mengunjungi setiap vertex dalam graph (dan kita
akan memproses nilai pada vertek yang di kunjungi). Dalam kunjungan secara sekuensial dari
suatu list, kita awali dari elemen pertama dan berakhir pada saat meraih elemen terakhir
dengan cara menginkremenkan secra sekuensial index dalam list. Pada bagian ini hanya di
bahas dua kunjungan dalam suatu graph yaitu Depth First Search atau DFS dan Breadth First
Search atau BFS.

10.1. DEPTH FIRST SEARCH (DFS)

Sebagai awal dapat di tentukan dari vertek mana saja, dan vertek selanjutnya yang
akan di kunjungi dalam metode DFS adalah berupa vertek yang berdekatan dengan titik
awalnya , yang mempunyai nilai kedalaman tertinggi dan kunjungan berikutnya adalah vertek
terdekat selanjutnya begitu seterusnya hingga seluruh node yang berdekatan pada vertek
tersebut tidak dikunjungi. Kita akan mengulang cara ini untuk setiap vertek yang di kunjugi
dalam graph.
Perhatikan gambar di bawah ini, Jika V1 merupakan titik awal dalam traversal
kemudian seperti yang terlihat, V2, V3 dan V8 merupakan vertek yang berdekatan dengan
V1. Sekarang, misalnya kita akan mengunjungi vertek tersebut, Sesuai prinsip dalam DFS,
kita harus mengunjungi V8 dulu dan kemudian baru V2 dan V3. Sehingga untuk tetap pada
jalur dimana vertek tersebut akan di kunjungi selanjutnya, kita akan memanfaatkan STACK
yang akan menangani nilai vertek dalam DFS.

Gambar 41. Skema Breadth dan Depth

137
Algoritma:
Step-1: Set titik awal dari traversal dan push ke stack
Step-2: Pop stack dan tambahkan vertek yang di pop ke lis vertek yang sudah dikunjungi
Step-3: Cari vertek yang berdekatan yang yaitu vertek yang baru saja di kunjungi ( dari matrik
keterhubungan atau berdekatan )
Step-4: Push vertek yang berdekatan ke dalam stack (dalam urutan yang menaik dari
kedalamanya) bila tidak di kunjungi dan tidak berada dalam stack.
Step-5: Lanjutkan langkah ke dua jika stack tidak kosong

9.1.1. REPRESENTASI LARIK DAN LINK LIST

Dalam C dapat di tuliskan sebagai berikut, Salah satu representasi graph adalah dengan
matrik n2 (matrik dengan n baris dan n kolom, artinya baris dan kolom berhubungan ke setiap vertex
pada graph). Jika ada edge dari vi ke vj maka entri dalam matrik dengan index baris sebagai v i
dan index kolom sebagai vj yang di set ke-1 (adj[vi, vj] = 1, jika (vi, vj) adalah suatu edge dari
graph G). Jika e adalah total jumlah edge dalam graph, maka ada entri 2e yang di set ke 1,
selama G adalah graph tak berarah. Jika G adalah graph berarah, hanya entri e yang di set ke-1
dalam matrik keterhubungan, seperti tamapak pada gambar di bawah ini.

Gambar 42. Matrik Keterhubungan dalam graph berarah dan tidak berarah
Representasi Larik

Gambar 43. Representasi List

138
9.1.2. MEMBUAT MATRIK KETERHUBUNGAN
Untuk menjalankan algoritma traversal ini, terlebih dahulu kita akan sajikan pembuatan
matrik keterhubungan. Potongan kode di bawah ini merupakan salah satu cara untuk membuat
matrik keterhubungan.

void buildadjm(int adj[][max], int n) {

int i,j;
for(i=0;i<n;i++)
for(j=0;j<n;j++) {
printf(“Masukan 1 jika ada edge dari %d ke %d,
kalau tidak 0 \n", i,j);
scanf("%d",&adj[i][j]);
}
}

Selanjutnya algoritma DFS di sajikan untuk melakukan traversal pada representasi larik,
secara rekursif.

void dfs(int x,int visited[],int adj[][max],int n) {

int j;
visited[x] = 1;
printf(“Node yang di kunjungi %d\n",x);
for(j=0;j<n;j++)
if(adj[x][j] ==1 && visited[j] ==0)
dfs(j,visited,adj,n);
}
Contoh Kasus :
Jika diberikan input matrik sebagai graph berikut ini

Dengan menggunakan algoritma DFS di atas di dapatkan keluaran dari node yang di kunjungi
adalah : 0 1 2 6 8 5 3 4 7

139
Karena ada matrik 9X9, maka parameter pertama dari algoritma dfs adalah index dari matrik
tersebut (mulai 0-9), lalu parameter kedua adalah stack yang di pakai untuk menampung node
yang di kunjungi, lalu input matriknya sebagai parameter ke tiga dan terakhir adalah besar
matrik (9), jadi ada sembilan langkah untuk mneghasilkan output pada matrik di atas :
for(i=0; i<n; i++)
if(visited[i] ==0)
dfs(i,visited,mat,n);

Perhatikan langkah berikut :

Node Mark Node Next
STEP Mat(x,j) Connected
Visited (x) Visited(x) Visit
1 0 0 (0,0) F
1 (0,1) T 1
2 1 1 (1,0) T
0 (1,1) F
0 (1,2) T 2
3 2 0 (2,0) F
1 (2,1) T
0 (2,2) F
0 (2,3) F
0 (2,4) F
0 (2,5) F
1 (2,6) T 6
4 6 0 (6,0) F
0 (6,1) F
1 (6,2) T
0 (6,3) F
0 (6,4) F
0 (6,5) F
0 (6,6) F
0 (6,7) F
1 (6,8) T 8
5 8 0 (8,0) F
0 (8,1) F
0 (8,2) F
0 (8,3) F
0 (8,4) F
1 (8,5) T 5
6 5 0 (5,0) F
0 (5,1) F
0 (5,2) F
1 (5,3) T 3
7 3 0 (3,0) F

140
 1 (3,1) T
0 (3,2) F
0 (3,3) F
1 (3,4) T 4
8 4 1 (4,0) T
0 (4,1) F
0 (4,2) F
1 (4,3) T
0 (4,4) F
0 (4,5) F
0 (4,6) F
0 (4,7) F
0 (4,8) F
1 (3,4) T
1 (3,5) T
0 (3,6) F
0 (3,7) F
0 (3,8) F
1 (5,3) T
0 (5,4) F
0 (5,5) F
0 (5,6) F
0 (5,7) F
1 (5,8) T
1 (8,5) T
1 (8,6) T
0 (8,7) F
0 (8,8) F
1 (6,8) T
1 (2,6) T
0 (2,7) F
0 (2,8) F
1 (1,2) T
1 (1,3) T
0 (1,4) F
0 (1,5) F
0 (1,6) F
0 (1,7) F
0 (1,8) F
0 (0,0) F
1 (0,1) T
0 (0,2) F
0 (0,3) F
1 (0,4) T
0 (0,5) F
0 (0,6) F
0 (0,7) F
0 (0,8) F
9 7 0 (7,0) F 7

141
 0 (7,1) F
0 (7,2) F
0 (7,3) F
0 (7,4) F
0 (7,5) F
1 (7,6) T
0 (7,7) F
1 (7,8) T Selesai

10.2. BREADTH FIRST SEARCH (BFS)

Idenya mirip dengan algoritma prim dan dijkstra, Traversal dimulai dari simpul v. Secara
umum algoritmanya adalah sebagai berikut :

1. Kunjungi simpul v,
2. Kunjungi semua simpul yang bertetangga dengan simpul v terlebih dahulu.
3. Kunjungi simpul yang belum dikunjungi dan bertetangga dengan simpul-
simpul yang tadi dikunjungi, demikian seterusnya.

Jika graf berbentuk pohor berakar, maka semua simpul pada aras d dikunjungi lebih dahulu
sebelum simpul-simpul pada aras d + 1. Pada umumnya graf di representasikan baik secara array
ataupun list Dalam kuliah ini menggunakan Link LIST , dalam hal ini queue :

struct node {
int data;
struct node *link;
};
Algoritma BFS secara umum dalam psuedocode :

142
Contoh : perhatikan urutan langkah yang menggambarkan jalanya algoritma BFS di bawah
ini, root adalah s.

Step 1.

Step 2

Step 3

Step 4

143
Step 5

Step 6

Step 7

Step 8

144
Step 9

Gambar 44. Step BFS

Awal vertex (node) adalah S, Edge hitam solid= edge yang di temukan, Edge abu-abu adalah
error edge (karena tidak ada hubungan pd vertex tsb dg ancestornya). Running time algoritma
ini adalah O(V+E).

Dari Gambaran contoh di atas, maka kita dapat memanfaatkan algoritma ini untuk beberapa
hal yang berkaitan dengan Graph di antaranya adalah :

• Memerikasa apakah graph terhubung atau tidak

• menghitung spanning forest graph
• Menghitung, tiap vertex dalam graph, jalur dengab jumlah edge minimum antara
vertex awal dan current vertex atau ketiadaan path.
• Menghitung cycle dalam graph atau ketiadaan cycle.

Di bawah ini di berikan potongan fungsi penting dalam algoritma BFS sebagi bekal untuk
lebih mendalami dan mengimplementasikannya dalam suatu aplikasi, misal MAZE problem.
Prosedur buildadjm, berguna untuk membentu suatu matrik keterhubungan, sebagai
representasi dari graph.
void buildadjm(int adj[][MAX], int n) {
int i,j;
printf("Masukan Matrik keterhubungan\n",i,j);
for(i=0;i<n;i++)
for(j=0;j<n;j++)
scanf("%d",&adj[i][j]);
}

Fungsi addqueue merupakan fungsi utilitas yang di gunakan untuk menyimpan informasi dari
node dalam graph yang dikunjungi,

145
struct node *addqueue(struct node *p,int val) {
struct node *temp;
if(p == NULL) {
p = (struct node *) malloc(sizeof(struct node));
/* insert node pertama(root)*/
if(p == NULL) {
printf("Alokasi Gagal\n"); exit(0);
}
p->data = val; p->link=NULL;
} else {
temp= p;
while(temp->link != NULL) {
temp = temp->link;
}
temp->link= (struct node*)malloc(sizeof(struct node));
temp = temp->link;
if(temp == NULL){
printf("Cannot allocate\n"); exit(0);
}
temp->data = val; temp->link = NULL;
}
return(p);
}

Fungsi deleteq merupakan fungsi utilitas yang di gunakan untuk melakukan penghapusan
informasi dari node dalam graph yang sudah dikunjungi,

struct node *deleteq(struct node *p,int *val) {

struct node *temp;
if(p == NULL) {
printf("queue kosong\n");
return(NULL);
}
*val = p->data;
temp = p;
p = p->link;
free(temp);
return(p);
}

Prosedur utama dari algoritma BFS, yang memanfaatkan fungsi dan prosedur utilitas di atas
secara lengkap di sajikan di bawah ini.

146
void
bfs(int adj[][MAX],int x,int visited[], int n, struct node **p){
int y,j,k;
*p = addqueue(*p,x);
do{
*p = deleteq(*p,&y);
if(visited[y] == 0){
printf("\nnode visited = %d\t",y);
visited[y] = 1;
for(j=0;j<n;j++)
if((adj[y][j] ==1) && (visited[j] == 0))
*p = addqueue(*p,j);
}
}while((*p)!= NULL);
}

Contoh aplikasi , jika di berikan matrik 9X9 sebagai representasi dari suatu graph sebagai
berikut di bawah ini gambar a maka graph yang terbentuk secara grafik adalah seperti gambar
b dan hasil traversal dari algoritma di berikan pada gambar c

a b c

Gambar 45. Matrik, graph dan hasil traversal (a,b,c)

Awal simpul adalah V1, dari graf G di bawah dan kunjungan BFS menghasilkan :
v1,v2,v5,v3,v4,v7,v6,v8,v9

147
 Gambar 46. Graph BFS

10.3. HILL CLIMBING

Pada bagian ini akan langsung di uraikan dalam suatu kasus untuk menjelaskan teknik
traversal dan pencarian dalam metode Hill Climbing. Secara teroritis akan di bahas secara
singkat, sekaligus akan di berikan contoh kasus untuk traversal BFS, DFS dan Hill Climbing
untuk di perbandingkan secara algoritmik.

Ide dasar dari algoritma ini adalah, akan mencari state yang lebih baik dari state saat
ini, artinya algoritma ini akan memilih langkah selanjutnya pada setiap titik atau node yang
muncul untuk di tempatkan pada tujuan yang terdekat (dengan demikian merupakan jarak
terjauh dari posisi saat ini). Misal kita dari kota A akan menuju ke kota D, dimana kita dapat
melalui 2 buah kota lainnya yaitu B dan C. Kita harus dapat menentukan apakah kota B dan
C ada yang lebih dekat dengan D daripada kota A.

Dalam tiap langkahnya hill climibing akan selalu membuat state selanjutnya menjadi best
successor dari state saat ini, dan akan kita melangkah hanya jika successor-nya lebih baik dari
state saat ini. Algoritma dapat di gambarkan sebagai berikut :
1. Mulai dengan state awal = initial-state.
2. Hingga state awal = state tujuan ATAU jika tidak ada perubahan pada state awal maka :

148
 1. Ambil successor state awal tersebut dan gunakan fungsi evaluasi untuk mencatat
nilai/score pada tiap successor.
2. Jika salah satu successor memiliki score yang lebih baik dari state awal-nya maka
set state awal baru dengan successor yang memiliki score terbaik.
Algoritma ini akan berhenti apablia tidak ada suksesor pada state awal yang lebih baik dari
state awal tersebut.

Contoh :

Perhatikan 2 Kasus TSP di bawah ini

149
 Gambar 47. Graph TSP

Idenya adalah bagaimana seorang sales akan mengunjungi seluruh kota dalam area tersebut
tanpa melakukan kunjungan pada kota yang sama sebanyak 2 kali (kecuali kota pertama) ,
setelah mengunjugi seluruh kota, maka salesman akan kembali ke kota pertama. Tujuan dari
TSP ini adalah menemukan rute optimal, yang membunyai cost terkecil, jarak terkecil, cepat
dan sebagainya.

10.4. BEST FIRST SEARCH

Best first search mirip dengan hill climbing, algoritma ini memakai fungsi evaluasi dan
selalu memilih node selanjutny yang mempunyai score terbaik. Bagaimanapun juga algoritma
ini masih mencari seluruh kemungkinan dari path yang ada. Best First search menggunakan
agenda seperti dalam bfs atau dfs, suksesor yang memiliki score terbaik akan di evaluasi dan
di tambahkan dalam suatu list, Algoritma dasarnya adalah sebagai berikut :
1. Di mulai dengan open = [initial-state].
2. Selama open [] kerjakan
1. Ambil node terbaik pada open.
2. jika node tersebut adalah berupa node tujuan/goal maka, kembali dengan sukses.
Selain itu cari suksesor.
3. Assign score node suksesor dengan fungsi evaluasi dan tambahkan score node ke
open (ingat ``open'' adalah suatu agenda, seperti dalam BFS/DFS.)

150
10.5. A* (A-START)
Dari bentuk traversal sederhana seperti di terangkan di atas, best first search merupakan
salah satu teknik yang berguna, tetapi tidak memperhitungkan cost dari path sejauh ini saat
memilih node selanjutnya. Jadi, kita akan menemukan solusi tetapi bukan merupakan solusi
yang bagus. Ada varian dari best first search yang di kenal dengan A* yaitu metode pencarian
solusi dengan total minimal panjang atau cost dari solusi path. Algoritma ini
mengkombinasikan kelebihan dari breadth first search, dimana shortest path dapat di temukan
pertama, dan dengan kelebihan dari best first search, dimana node yang kita duga adalah yang
paling dekat ke solusi yang akan di eksplorasi ekmudian.
Score algoritma A* yang di assign ke node merupakan kombinasi dari cost path dan
cost solusi yang di estimasikan. Hal ini secara normal di ekspresikan dengan fungsi evaluasi f,
yang melibatkan jumlahan nilai yang di kembalikan oleh 2 fungsi g dan h, g mengembalikan
cost dari path (dari initial state) ke node yang di cari, dan h mengembalikan sisa cost yang di
estimasikan ke goal state:
f(Node) = g(Node) + h(Node)
Algoritma A* mencari dengan cara yang sama dengan best first algorithm, tetapi kita akan
menggunakan sedikit fungsi evaluasi yang agak kompleks. (Node terbaik yang kita cari adalah
yang memiliki score atau cost terendah).

function A*(start,goal)
{* Himpunan node yang akan di evaluasi.*}
closedset := 
{* himpunan node tentative yang akan dievaluasi.*}
openset := {initial node}
{* Jarak dari start pada optimal path.*}
g_score[start] := 0
h_score[start] := heuristic_estimate_of_distance(start, goal)
{* Mengestimasikan total distance dari start ke goal lewat y.*}
f_score[start] := h_score[start]

151
 while openset
x := node dalam openset yg bernilai terendah dalam f_score[]
if x = goal
return reconstruct_path(came_from,goal)
remove x from openset
add x to closedset
foreach y in neighbor_nodes(x)
if y in closedset
continue
tentative_g_score := g_score[x] + dist_between(x,y)

if y not in openset
add y to openset
tentative_is_better := true
elseif tentative_g_score < g_score[y]
tentative_is_better := true
else
tentative_is_better := false
if tentative_is_better = true
came_from[y] := x
g_score[y] := tentative_g_score
h_score[y] := heuristic_estimate_of_distance(y, goal)
f_score[y] := g_score[y] + h_score[y]
return failure

function reconstruct_path(came_from,current_node)
if came_from[current_node] is set
p = reconstruct_path(came_from,came_from[current_node])
return (p + current_node)
else
return the empty path

10.6. TERMINOLOGY
Suatu node adalah state dalam dunia problem yang dapat di cari di dalamnya. Pada
pathfinding, suatu node hanya berupa koordinat 2d. Contoh misal pada 8-puzzle node
merupakan sluruh posisi pada kotak dalam papan. Selanjutnya seluruh node akan di atur
dalam aturan graph dimana terdapat suatu edge yang menghubungkan antar node tersebut
yang dapat mewakili untuk penyelesaian masalah yang di hadapi. Dalam diagram 8-puzzle
edges di tunjukan sebagai garis biru, seperti tampak pada gambar di bawah. Ruang Status
(State space), adalah penyelesaian masalah yang di awali dengan start state, dan kemudian
untuk setiap node kita akan mengekspansi seluruh node dalam graph dengan mengaplikasikan
seluruh kemungkinan gerakan yang dapat di buat di setiap titiknya.

152
Contoh Implementasi Algoritma A* pada 8 puzlle

Gambar 48. Tree Status Space

153
 BAB X
BACKTRACKING

10.1. TEKNIK BACKTRACKING

Misalkan kita harus membuat suatu rangkaian keputusan dari beberapa pilihan yang
berbeda, dimana kita tidak punya cukup informasi untuk mengetahui apa yang akan kita pilih
nantinya, setiap keputusan memiliki beberapa pilihan. Beberapa urutan keputusan (mungkin
lebih dari satu) bias jadi suatu solusi bagi masalah yang kita hadapi. Inilah yang di sebut
dengan teknik Backtracking yaitu suatu cara atau metode untuk mencari keputusan dari
bermacam-macam pilihan yang tidak di ketahui sebelumnya, hingga kita menemukan, bahwa
salah satu pilihan adalah yang kita perlukan.
Secara definisi dalam ilmu komputer backtracking sangat berkaitan dengan teknik
pencarian brute-force. Pencarian Brute-force merupakan teknik pemecah masalah umum yang
mencari solusi secara mudah dengan mengenumerasi secara sistematis seluruh kandidat dan
memeriksa apakah ada diantaranya yang memenuhi criteria yang di perlukan. Sedangkan
Backtracking merupakan teknik yang lebih halus dan bagus dari pada brute force dan juga
tidak naif.
Backtracking mengenumerasi hanya satu kemungkinan yang memenuhi property dari
masalah yang di hadapi. Hal ini dapat di buat untuk mencari jawaban akhir dengan cara
bergerak kedepan kea rah rangkaian pilihan yang di hadapi. Pendeknya pencarian solusi dari
awal hingga suatu ujung dari salah satu pilihan yang ada, dan jika tidak ketemu, maka kita
akan kembali lagi, dan mencoba kombinasi pilihan yang lain untuk di lakukan pencarian. Hal
ini akan berakhir jika semua pilihan kemungkinan jawaban sudah di coba dan belum
menemukan pemecah masalah maka pencarian dianggap gagal, sebaliknya jika ketemu di
salah satu alur pilihan kandidat solusi di anggap berhasil. Representasi fisik dari abstraksi
untuk melakukan teknik ini adalah berdasarkan suatu tree, dimana dia dapat mempunyai
banyak cabang sebagai kandidat solusi masalah dan node yang di temukan merupakan solusi
yang di cari. Beberapa contoh permasalahan yang dapat di selesaikan dengan metode
backtracking di berikan di bawah ini.

154
10.4.2. SOLVING MAZE
Diberikan suatu maze, tentukan jalur dari awal hingga akhir, pada tiap interseksi (cabang),
kita harus menentukan pilihan antara 3 atau lebih sedikit keputusan yang harus di ambil :
Terus lurus, Kekiri dan Kekanan. Anda tidak punya cukup informasi untuk memilih secara
benar, tiap pilihan mengawali himpunan pilihan lainnya. Satu atau lebih ururtan pilihan
mungkin (mungkin tidak) menemukan solusi. Misal labirin (maze), di tandai dengan X sebagai
tembok yang tidak dapat di lewati, I adalah start node awal pencarian dan O adalah akhir
pencarian, dan @ adalah jalan yang di temukan.
Input Maze Valid
XXXXXXXXXXXXXXXIXXX XXXXXXXXXXXXXXXIXXX
X X X@@@@@@@@@@@@@@@ X
X XXXXXXXXXXXXXXXXX X@XXXXXXXXXXXXXXXXX
X X X X@@@@@@@@@@@ X X
X XXX XXXXX@X X X X
X XXX XXXXX X X X X
X X X X@X X X X
X XX XXXXX X X X XXX X@X X X X
X X X XXX X X X X X X X X X@X X X
XXX XX XX XXXXXXXXXXXOXXXXXXX
XXXXXXXXXXXOXXXXXXX
XXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXX
XX X X X X X X
X X XXXX XXX XXXXXXX X X XXXX XXX XXXXXXX
XXX X X X X@@@@@@@ X
X X X XXXXX XXX X XX X X X@XXXXX@XXX X XX
X XXX X X X X X XX X XXX@X X@X X X XX
I X X X XXXXXX I@@@@@X X@X XXXXXX
X XXXXX X X X X XXXXX X X@@@@@@@@X
X X X X XX O X X X X XX@O
XXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXX
Input Maze invalid (maze3)
XXXXXXXXXIXXXXXXXXX XXXXXXXXXIXXXXXXXXX
X X XX XX X X X X XX XX X X
XX X X XX X X X X X X
X XXXXX X X XXXXX X X XXXXX X X XXXXX X
X O X X O X
X XXXXX X X XXXXX X X XXXXX X X XXXXX X
XX X X XX X X X X X X
X X XX XX X X
X X XX XX X X XXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXX
Gambar 49. Labirin

155
10.4.3. PEWARNAAN PETA
Anda di harapkan untuk mewarnai peta dengan tidak lebih dari 4 warna, misal, merah,
kuning, hijau dan biru. Negara yang berdekatan harus memiliki warna yang berbeda dan kita
tidak cukup memiliki informasi untuk menentukan warna. Tiap pilihan mengawali himpunan
pilihan lainnya, Satu atau lebih urutan dari pilihan mungkin (mungkin tidak) memiliki solusi.

Gambar 50. Warna Peta

Jadi masalah pewarnaan sebanyak m, konsern terhadap bagaimana menemukan semua cara
untuk melakukan pewarnaan pada graph tidak berarah dengan menggunakan m warna yang
berbeda, sehingga tidak ada vertek yang terhubung berwarna sama, inilah yang di sebut
sebagai m-coloring problem untuk menemukan tiap nilai pada m.

V1 V2

V4 V3

Gambar 51. Graph Map Coloring

Perhatikan gambar di atas, tidak ada solusi untuk 2 coloring problem dalam graph tersebut,
karena jika kita pakai 2 warna yang erbeda, tidak ada cara untuk mewarnai vertek yang tidak
berhubungan dengan warna yang sama. Solusinya adalah 3 coloring problem sebagai berikut:
Vertek Warna

V1 warna1
V2 warna2
V3 warna3
V4 warna4

156
Ada 6 solusi untuk 3 coloring problem, tetapi 6 solusi tersebut hanya berada dalam cara
permutasi warna, misal solusi lainnya adalah, v1 dengan color2 dan v4 dengan color1 dan v3
dengan color3. Implementasi dari pewarnaan graph adalah dalam map coloring, atau sering di
sebut planar graph, seprti terlihat pada gambar berikut.

V2

V1
V3
V4

V5

V V
1 2

V V
4 3

V
5

Gambar 52. Peta Warna dan graph

Algorithm
Problem: Tentukan seluru cara bagaimana mewarnai vertek pada undirected graph, dengan
menggunakan hanya m warna, sehingga vertek yang berhubungan tidak mempunyai warna
sama.

Input : Nilai integer positif n dan m serta graph tak berarah yang mengandung n vertek,
graph di wakili dengan nXn array W, dimana W[j,i] adalah bernilai true jika ada edge antara vi
dan vj dan lainya false.

Output:Seluruh kemungkinan pewarnaan pada graph, dengan setidaknya m warna, dengan

demikian 2 vertek yang berhubungan tidak mempunyai warna yang sama. Output untuk tiap
pewarnaannya adalah dalam array vcolor dari n integer, dimana vcolor[i] adalah warna
(berupa nilai integer antara 1 hingga m) yang di assign pada vertek ke-i.

157
procedure m_coloring(i:index);
var
color:integer;
begin
if promising(i) then
begin
if i=n then
write(vcolor[i] hingga vcolor[n])
else
begin
for color:=1 to m do
begin
vcolor[i+1]:=color; {cari tiap warna utk vertek}
{selanjutnya}
m_coloring(i+1);
end;
end;
end;
end;
function promising(i:index):booolean;
var
j:index;
begin
promising:=true;
j:=I;
while j<I and promising do {cek keterhubungan}
begin
if w[I,j] and vcolor[i]=vcolor[j] then {vertek berwarna}
promising:=false
j:=j+1
end;
end;

n,m,w dan vcolor bukanlah input pada routine tersebut, dalam implementasi algoritma, rutin
di definisikan secara local dimana n,m dan w sebagai input sedang vcolor di definisikan secara
local, pemanggilan ruting misalnya m_coloring(0), akan mengeksekusi :

2m n 1  1 n
1  m  m  ...  m 
m 1

158
10.4.4. SOLVING PUZZLE
Dalam puzzle ini, seluruh lobang kecuali satu terisi dengan warna putih. Kita dapat
melompati lobang tersebut dan lobang yang di lompati akan di hilangkan warnanya (jika
lobang yang di lompati berwarna hitam akan menjadi putih) . Lobang akan dihilangkan
seluruhnya kecuali yang terakhir. Kita tidak punya cukup informasi untuk melompat secara
benar, tiap pilihan mengawali himpunan pilihan lainnya, Satu atau lebih urutan dari pilihan
mungkin (mungkin tidak) memiliki solusi.

10.1. EIGHT PUZZLE

Eight puzzle atau 8 puzzle merupakan puzzle tradisional dimana terdapat matriks 3X3
yang berisi 8 kotak terisi dengan angka atau huruf abjad teracak dan satu kotak kosong
(initial state). Tugas kita adalah mengurutkan acakan huruf atau angka menjadi susunan
yang di inginkan (goal state).

Initial State Goal State

Gambar 53. Puzzle 8

159
Goal state dapat di temukan dari initial state dengan 5 langkah seperti di bawah ini :

1. Blank Up
2. Blank Up
3. Blank Left
4. Blank Down
5. Blank Right

Sehingga goal state terdapat 2 kemungkinan, seperti di bawah ini :

Goal State A Goal State B

Gambar 54. Puzzle 8 dan state

10.2. QUEEN PROBLEM

Permasalahan ratu, seperti yang di ambil dalam permainan catur, merupakan masalah
dasar pencarian lainnnya yang masuk dalam kategori permainan. Jika di berikan sejumlah ratu
(8 buah), yang terdapat dalam bidang matrik sebesar 8 X 8, bagaimana kita meletakan tiap-
tiap ratu tersebut sedemikian rupa sehingga mereka tidak saling memekan satu sama lainnya,
ada berapa pola yang terbentuk dari susunan yang merupakan solusi.

Gambar 55. Queen Problem

160
 Gambar 55. Queen Problem (lanjutan)

Berapa jumlah maximum queen yang dapat di tempatkan pada papan catur berukuran sedemikian
rupa sehingga tidak ada 2 queen yang saling menyerang?. Jawabannya adalah queen, Namun ada
berapa kemungkinan n queen tersebut dapat di letakan pada papan, yang memenuhi ketentuan seperti
di atas ? , Berapa jumlah minimumnya ??

10.3. BISHOP PROBLEM

Gambar 56. Bishop Problem

Temukan jumlah maximum dari peluncur (bishops) yang dapat di tempatkan pada papan
sedemikian rupa sehingga mereka tidak saling dalam posisi menyerang. Jawabannya
161
adalah , di berikan urutan 2, 4, 6, 8, ... (bilangan genap) untuk , 3, .... Satu solusi
maximal untuk adalah seperti di ilustrasikan di atas. Jumlah perbedaan maksimal dari
pangaturan maksimal untuk , 2, ... peluncur adalah 1, 4, 26, 260, 3368, .... Jumlah rotasi
dan refleksi dari solusi yang berbeda pada papan untuk adalah

(1)

Untuk . Atau

(2)

Dimana adalah fungsi floor, dengan , 2, ... as 1, 1, 2, 3, 6, 10, 20, 36, ...

Gambar 57. Solusi Bishop Problem

Solusi jumlah minimum untuk nxn adalah n

10.4. KINGS PROBLEM

Gambar 58. Kings Problem

162
Tentukan berapa banyak raja yang tidak saling serang yang dapat di tempatkan pada papan
. untuk , Solusinya adalah 16, dan solusi ummumnya adalah

(1)

Untuk kotak ganda 1, 1, 4, 4, 9, 9, 16, 16, ... dapat di generate dengan fungsi

Gambar 59. Kings Problem Solution

Solusi minimal dari king problem yang tidak saling menyerang untuk adalah 9

10.5. KNIGHT PROBLEM

Gambar 60. Knight Problem Solution

163
Tentukan berapa banyak kuda (knight) yang tidak saling menyerang pada papan catur
, Untuk , solusinya 32 , Solusi umumnya adalah :

(1)

Di berikan urutan 1, 4, 5, 8, 13, 18, 25, ...

Gambar 62. Knight Problem

Jumlah minimal knight yang di perlukan untuk menduduki atau menyerang pada setiap papan
adalah 1, 4, 4, 4, 5, 8, 10, .... Jumlah solusi adalah 1, 1, 2, 3, 8, 22, 3, ... .

10.6. ROOK PROBLEM

Gambar 63. Rook Problem Solution

164
Beteng ( rook) dalam catur dapat bergerak secara vertical dan horisontal. Jumlah maximum
beteng yang tidak saling menyerang yan dapat di letakan dalam papan adalah .
Sehingga Jumlah total cara meletakan beteng dalam posisi tidak menyerang dari adalah
sehingga secara umum bentuk polinomialnya :

Dimana koefisien memberikan jumlah cara tidak saling serang yang dapat di
tempatkan pada papan .

Jumlah rotasi dan refleksi yang tidak equivalen dalam menempatkan beteng yang tidak
saling menyerang pada papan adalah 1, 2, 7, 23, 115, 694, ...

Dari beberapa contoh di atas , kita dapat menyimpulkan bahwa hasil dari metode
tersebut adalah suatu vector yang berisi Artinya bahwa kita harus mendkodekan solusi
kedalam suatu vector. Selain itu tugas kita juga harus mengidentifikasi sedertan elemen
sumber dari mana kita akan membangun jalur kemungkinan dalam suatu tree, atau hanya
membuat vector sederhana dimana kita akan bergerak maju dan mencoba untuk
mengkombinasikan elemen dalam suatu array.

10.5. DISAIN SOLUSI DALAM PENGKODEAN

Sekarang kita coba mengkodekan secara vector dari metode di atas, kita akan
menggunakan vector X[ ] sebagai vector solusi. Semua kandidat kemungkinan akan di ambil
dari array A1, A2, ..., dan An. Kita akan menggunakan strategi rekursif untuk menyelesaikan
scenario untuk merunut balik, jika tidak di temukan solusi dalam vector. Suatu variable, k di
perlukan untuk merefer level ke-k dari tree yang mengandung elemen yang di kombinasikan
hingga array Ak . Perhatikan sketsa di bawah ini

165
 Gambar 64. Disain Stack Array N queen
Diagram di atas akan masuk akal jika kita datang pada vector selanjutnya. Diagram di atas
merupakan suatu "Puzzle of N Queens" pada papan catur 4x4. Seperti terlihat solusi vector X[
] keliahatan berkelakuan mirip dengan stack, kita akan push dan pop elemen ked an dari stack
tersebu. Kita akan mulai dari root dan mengunjungi tiap node anaknya, dari node tersebut kita
akan analisa apakah ada kandidat solusi yang potensial jika ada, kita akan push ke stack dan
jika tidak ada, akan kita gerakan naik satu level, begitu seterusnya, terakhir jika tidak ada
solusi pada level tersebut, kita pop dan mencari alternative lainnya.

10.6. PROBLEM DAN SOLUSI

Sebelum kita mulai, kta harus sepakati bahwa yang di maksud dengan "Puzzle of N
Queens." Adalah bagaimana kita dapat meletakkan N queen (Ratu) pada suatu papan catur N
x N sedemikian sehingga ratu tersebut tidak saling serang satu sama lain. Tentu saja kita akan
meletakannya jika tidak ada ratu yang berada di satu baris atau kolom, bahkan diagonalnya.
Juga kita tidak akan berhenti saat solusi pertama di temukan. Batasannya adalah kita harus
menemukan seluruh kemungkinan penempatan dari N ratu pada papan tersebut, jadi kita
mungkin menemukan banyak solusi terhadapnya. Dalam contoh ini kita hanya mengamati
pada papan catur 4 x 4. Dengan demikian, kita dapat meminimalkan jumlah ratu hanya 4 buah
yang harus kita letakan. Tidak di perlukan alokasi papan catur seluruhnya, dan hanya 4X4 saja
yang kita perlukan, sehingga kita dapat melakukannya dengan vector satu dimensi saja. Index
166
vector akan berlaku sebagai baris dari papan catur, sementara nilai ang di kandung oleh vector
tersebut (X[index]) merepresentasikan kolom. Jika X[1] = 3, berarti ada ratu yang berokasi
pada baris pertama dan kolom ke 3. Kita akan bergerak dengan menggunakan cara terus, kiri
dan kanan, sehingga kandidat yang mungkin (kolom) dapat berupa angka dari 1 hingga 4,
yang berarti seluruh array A1, A2, A3, A4 berisi elemen {1, 2, 3, 4}. Untuk hal tersbut kita
sebenarnya tidak perlu mengalokasikan dan menggunakan aray tersebut. Kita cukup
melakukan loop dari 1 hingga 4. Dalam rangka mengimplementasikan algoritma ini, kita
perlu beberapa fungsi yang kita akan perlukan seperti back(), possible() , solution().
Algoritma backtracking untuk solusi di atas dapat di berikan sebagai berikut.
function backtracking (depth)
/*
jika solusi valid maka
ret cetak solusi
selain itu
iterasi tiap elemen dari A[]
X[depth]  element
if possible candidate (depth + 1)
backtracking (depth + 1)
*/
Dan beberapa fungsi penting di bawah ini akan membantu mendapatkan solusi yang di
maksud dalam pseudo code di atas. Fungsi possible(), berguna untuk mendapatkan kandidat
yang mungkin akan di ambil. Pada dasarnya tiap kali kita berencana untu menenmpatkan ratu
lainnya. Kita perlu memeriksa lokasi yang akan di spesifikasikannya (secara kolom, baris dan
diagonal) tidak ada yang berpotongan
integer possible(integer k)
/*
iterasi (i1;i<k;i++)
jika (x[i]=x[k] atau abs(x[i]-x[k])=k-i) maka
ret 0;
ret 1;
*/
Karena array X[]adalah berdimensi tunggal, kita hanya dapat menempatkan satu elmen pada
tiap index, yang berarti, misal X[1],dapat hanya berisi satu nomer. Mengetahui hal tersebut,
criteria pertama yang di temukan (adalah tidak mungkin untuk menempatkan 2 ratu pada baris
yang sama). Selanjutnya menggunakan kondisi x[i] == x[k] kita dapat memby pass solusi ini
di mana ratu akan di tempatkan pada kolom yang sama. Terakhir , bahwa kondisi terakhir
167
menghilangkan kemungkinan ratu di tempatkan pada posisi yang secara diagonal sudah
pernah di lakukan.
Fungsi solusi () dalam puzzle ini hanya memeriksa bahwa posisi ratu tidak saling menyerang
sebelum di letakan pada papan.
boolean solusi(integer k)
/*
ret(k=n);
*/

Fungsi print() mencetak elemen array X[] hingga level ke-k.

void print(integer k)
/*
iterasi(i1;i<k+1;i++)
output(x[i]);
*/
Akhirnya implementasi rekursif dari algoritma backtracking berada dalam loop untuk
menempatkan ratu dalam table, pada tiap kemungkinan penempatan kolom pada baris. Kita
akan mendapatkan hasil dari fungsi possible(k + 1) yang akan memeriksa pergerakan solusi
selanjutnya. Jika demikian kita validasi bagian dengan menggerakan ke node selanjutnya,
begitu seterusnya.
void back(int k)
/*
jika (solusi(k)) maka
print(k);
selain itu
iterasi(x[k+1]1;x[k+1]<=n;x[k+1]++)
jika(possible(k+1))maka
back(k+1);
*/
Hasil dari algoritma di atas adalah, perhatikan sketsa sebelumnya.
2413
3142
Diagram solusi yang di dapatkan dari hasil algoritma pada papan 4X4, dengan 4 ratu.

168
 Gambar 65. 4 Queen Problem
Angka 2 4 1 3 berarti bahwa nilai vectornya adalah X[1] = 2; X[2] = 4; X[3] = 1; X[4] = 3,
yang berarti ratu pertama di letakan pada posisi (1,2), kedua di (2,4), ketiga di (3,1), dan
terakhir di (4,3). Hal yang sama berlaku pada kandidat solusi yang kedua. Secara visual,
dalam tree, maka dapat di gambarkan sebagai berikut, perhatikan bahwa node awal (root)
adalah kosong.

16 kombinasi

Gambar 66. Tree 4 Queen Problem

169
 Daftar Pustaka

Handbook of Algorithms and Data Structures In Pascal and C , Second Edition , G.H. Gonnet
ETH, Zurich, ADDISON -WESLEY PUBLISHING COMPANY 1991.
Introduction to Algorithms, Thomas H. Cormen, Charles E. Leiserson, and Ronald L. Rivest,
McGraw-Hill 1990.
Data Structures and Algorithm Analysis in C, Mark Allen Weiss,The Benjamin/Cummings
Publishing Co., Inc. All rights reserved 1993.
Fundamental Of Algorithmic,Gilles Brassard dan Paul Beatly, Prentice Hall Engelwood Cliffs,
New Jersey, 1996
Algorithms Design Techniques And Analysis, M.H. Alsuewalyel,Publishing House Of
Electronic Industry, 2002.
The Analysis Of Algorithms, Paul Walton Purdom, CBS Publishing Madison Avenue New
York, 1985
A Programmer’s Companion to Algorithm Analysis, Leiss, Ernst L., Taylor & Francis Group,
LLC,2006
Data Structures, Algorithms And Software Principles in C, Thomas A Standish,Addison
Wesley, 1995,California
The Art of Computer Programming, Vol 1,2,3,Donad E Knuth, Addison Wesley,
The C Programming Laguage, Second Edition, rian W Kernighan and Dennis M Ritchie,
Pretice Hall, Englewood Cliffs, N.J, 1988.
The Design And Analysis of Computer Algorithm, Alfred V Aho, John E. Hopcroft and Jeffery
D Ullman, Addison Wesley, 1974.
Data Structures and Algorithms, Alfred V. Aho, Bell Laboratories, Murray Hill, New Jersey
John E. Hopcroft, Cornell University, Ithaca, New York, Jeffrey D. Ullman,
Stanford University, Stanford, California,1999
Fundamentals of Data Structures, Ellis Horowitz and Sartaj Sahni, 1999
Data Structure And Algorithms In C++, Adam Drozdek, Thomson Learning, 2001.
Matematika Diskrit, Jong Jek Siang, Andi Offset,Yogyakarta, 2002
Matematika Diskrit, Rinaldi Munir, Irformatika, Bandung, 2002
Diktat Kuliah Strategi Algoritmik, Rinaldi Munir, 2007

170