Post on 20-Jan-2020
i
ANALISIS DAN PENERAPAN ALGORITMA STRING MATCHING PADA
APLIKASI PENCARIAN BERKAS DI KOMPUTER
Cover Luar
Skripsi
Diajukan untuk Memenuhi Persyaratan Memperoleh Gelar
Sarjana Komputer (S.Kom.)
Oleh :
SUPARDI
NIM : 103091029513
PROGRAM STUDI TEKNIK INFORMATIKA
FAKULTAS SAINS DAN TEKNOLOGI
UNIVERSITAS ISLAM NEGERI SYARIF HIDAYATULLAH
JAKARTA
2009
ii
ANALISIS DAN PENERAPAN ALGORITMA STRING MATCHING PADA
APLIKASI PENCARIAN BERKAS DI KOMPUTER
Cover Dalam
Skripsi
Diajukan untuk Memenuhi Persyaratan Memperoleh Gelar
Sarjana Komputer (S.Kom.)
Fakultas Sains dan Teknologi
Universitas Islam Negeri Syarif Hidayatullah Jakarta
Oleh :
SUPARDI
NIM : 103091029513
PROGRAM STUDI TEKNIK INFORMATIKA
FAKULTAS SAINS DAN TEKNOLOGI
UNIVERSITAS ISLAM NEGERI SYARIF HIDAYATULLAH
JAKARTA
2009
iii
ANALISIS DAN PENERAPAN ALGORITMA STRING MATCHING PADA
APLIKASI PENCARIAN BERKAS DI KOMPUTER
Lembar Pengesahan Pembimbing
Skripsi
Sebagai Salah Satu Syarat Untuk Memperoleh Gelar
Sarjana Komputer
Fakultas Sains dan Teknologi
Universitas Islam Negeri Syarif Hidayatullah Jakarta
Oleh
Supardi
103091029513
Menyetujui,
Pembimbing I,
Viva Arifin, MMSI
NIP. 150 378 016
Pembimbing II
Fitri Mintarsih, M.Kom
Mengetahui,
Ketua Program Studi Teknik Informatika
Yusuf Durachman, M.Sc, M.IT
NIP. 150 378 017
iv
PENGESAHAN UJIAN
Lembar Pengesahan Ujian
Skripsi yang berjudul “Analisis Dan Penerapan Algoritma String Matching Pada
Pencarian Berkas Di Komputer” telah di uji dan dinyatakan lulus dalam sidang
Munaqosah Fakultas Sains dan Teknologi, Universitas Islam Negeri Syarif
Hidayatullah Jakarta pada hari Kamis, 19 Februari 2009. Skripsi ini telah diterima
sebagai salah satu syarat untuk memperoleh gelar Sarjana Strata (S1) Jurusan
Teknik Informatika.
Jakarta, Januari 2009
Tim Penguji
Penguji I,
-
Penguji II,
-
Pembimbing I
Viva Arifin, MMSI
NIP. 150 378 016
Pembimbing II
Fitri Mintarsih, M.Kom
Mengetahui,
Dekan Fakultas Sains dan Teknologi
Dr. Syopiansyah Jaya Putra, M.Sis
NIP. 150 317 966
Ketua Program Studi Teknik Informatika
Yusuf Durachman, M.Sc, M.IT
NIP. 150 378 017
v
PERNYATAAN
Lembar Pernyataan
DENGAN INI SAYA MENYATAKAN BAHWA SKRIPSI INI BENAR-
BENAR HASIL KARYA SENDIRI YANG BELUM PERNAH DIAJUKAN
SEBAGAI SKRIPSI ATAU KARYA ILMIAH PADA PERGURUAN TINGGI
ATAU LEMBAGA MANAPUN.
Jakarta, Januari 2009
Supardi
103091029513
vi
LEMBAR PERSEMBAHAN
Lembar Persembahan
Skripsi ini ku persembahkan untuk temanku (Alm) Rosi Firman. Dahulu dia
selalu setia menemaniku, bermain, dan belajar bersama. Dia mengajariku berbagai
hal khususnya dunia komputer.
Do’aku untukmu, semoga kebaikan hatimu yang telah lalu bisa
meringankan dosa-dosamu. Amin.
Banyak kawan saya yang terlalu takut mengarang, maju mundur, sehingga tidak
pernah mengarang. Mereka tidak punya keberanian, karena ingin karangannya
sempurna. Mana ada di dunia ini yang sempurna.
(Buya Hamka)
vii
ABSTRAK
Abstraksi
SUPARDI, Analisis Dan Penerapan Algoritma String Matching Pada
Aplikasi Pencarian Berkas Di Komputer. (Di bawah bimbingan Viva Arifin,
MMSI dan Fitri Mintarsih, M.Kom)
Algoritma merupakan pondasi utama untuk membuat suatu program,
dengan algoritma yang efektif dan efisien maka program akan terasa lebih ringan
dan tidak membebani kinerja sebuah komputer.
Algoritma string matching merupakan suatu algoritma untuk melakukan
pencarian kemunculan pattern di dalam teks. Dengan menggunakan algoritma
string matching data yang akan dicari akan dicocokkan secara exact/tepat pada
suatu teks.
Pada karangan ilmiah ini penulis mencoba menerapkan algoritma string
matching dengan membuat aplikasi pencarian berkas di komputer. Penulis
menggunakan 3 (tiga) buah algoritma dari algoritma string matching, yaitu
algoritma brute force, algoritma knuth-morris-pratt, dan algoritma boyer-moore.
Kemudian penulis membandingkan algoritma tersebut untuk memperoleh mana
algoritma yang efektif dan efisien untuk aplikasi pencarian berkas di komputer.
Kata kunci : algoritma, pencarian berkas, string matching
viii
KATA PENGANTAR
Kata Pengatar
Bismillaahirrahmaanir Rahiim
Segala puji serta syukur penulis panjatkan kehadirat Allah SWT, Tuhan
semua, sekalian alam, yang menciptakan manusia dalam bentuk yang sebaik-
baiknya, dan tidaklah diciptakan jin dan manusia melaikan hanya untuk
menyembah kepada-Nya.
Alhamdulillah kupersembahkan untuk-Mu. Ya Allah atas berkat rahmat dan
hidayah-Mu jualah penulis dapat menyelesaikan skripsi ini. Shalawat serta salam
tak lupa juga terlimpah kepada junjungan kita Baginda Nabi Besar Muhammad
SAW, yang telah memerdekakan umatnya dari musuh utama manusia yaitu
kebodohan.
Dalam menyusun skripsi ini, penulis menyadari bahwa tidak dapat
terlaksana dengan baik tanpa bantuan dan bimbingan dari semua pihak. Pada
kesempatan ini, perkenankan penulis mengucapkan terima kasih kepada :
1. Bapak Dr. Syopiansyah Jaya Putra, M.Sis sekalu Dekan Fakultas Sains
dan Teknologi.
2. Ibu Viva Arifin, M.Si dan Ibu Fitri Mintarsih, M.Kom selaku dosen
pembimbing. Yang telah memberikan motivasi, dukungan, nasehat dan
membimbing penulis dalam menyelesaikan skripsi ini.
3. Bapak dan Ibu, sebagai penguji yang telah memberikan saran dan kritik
untuk tempat pengembangan disiplin ilmu bagi penulis.
4. Bapak Yusuf Durachman, M.Sc, M.IT, selaku Ketua Program Studi
Teknik Informatika, Fakultas Sains dan Teknologi.
5. Seluruh Dosen dan Staf Jurusan Teknik Informatika juga seluruh Staf
Fakultas Sains dan Teknologi.
6. Keluarga tercinta, Ibunda Suratmi dan kakak-kakak tercinta
Muhimuddin Salmoe, Endang Mulyani, Ety Maesaroh dan Erna
Hapipah, terima kasih atas doa-doanya.
7. Kawan-kawan seperjuangan Ali Huzaefi, Arip Saripudin, Fuad Lutfi,
Faishal Rahman, Iim Imamuddin, Imam Zarkasih, M. Samsul, Yudi
Defrizal.
8. M. Yasir yang telah meluangkan waktunya untuk membaca sekaligus
merevisi skripsi ini.
9. Serta semua pihak yang telah membantu dalam penyusunan laporan ini,
yang tidak dapat penulis cantumkan satu persatu.
Penulis menyadari skripsi ini masih banyak kekurangannya, oleh karena itu
penulis mengharapkan kritik dan sarannya. Akhir kata, dengan segala kerendahan
hati penulis mengucapkan terima kasih tak terhingga kepada semua pihak yang
membantu penyelesaian skripsi ini. Penulis juga berharap semoga skripsi ini
bermanfaat bagi pembaca umumnya dan bagi penulis khususnya.
Wassalam,
Jakarta, Maret 2009
Penulis
x
DAFTAR ISI
Daftar Isi
Cover Luar ............................................................................................................... i
Cover Dalam ........................................................................................................... ii
Lembar Pengesahan Pembimbing .......................................................................... iii
Lembar Pengesahan Ujian...................................................................................... iv
Lembar Pernyataan.................................................................................................. v
Lembar Persembahan ............................................................................................. vi
Abstraksi ............................................................................................................... vii
Kata Pengatar ....................................................................................................... viii
Daftar Isi.................................................................................................................. x
Daftar Tabel ......................................................................................................... xiii
Daftar Gambar ...................................................................................................... xiv
Daftar Istilah......................................................................................................... xvi
BAB I PENDAHULUAN .................................................................................... 1
1.1 Latar Belakang Masalah .................................................................. 1
1.2 Perumusan Masalah ......................................................................... 3
1.3 Batasan Masalah .............................................................................. 3
1.4 Tujuan Penelitian ............................................................................. 4
1.5 Manfaat Penelitian ........................................................................... 4
1.5.1 Bagi Penulis ......................................................................... 4
1.5.2 Bagi Universitas .................................................................. 5
1.5.3 Bagi Pengguna ..................................................................... 5
1.6 Metodologi Penelitian ..................................................................... 5
1.6.1 Metode Pengumpulan Data ................................................. 5
1.6.2 Metode Pengembangan Sistem ............................................ 6
1.7 Sistematika Penulisan ...................................................................... 7
BAB II LANDASAN TEORI .............................................................................. 9
2.1 Algoritma ......................................................................................... 9
2.1.1 Definisi Algoritma ............................................................... 9
2.1.2 Ciri Algoritma ...................................................................... 9
2.1.3 Jenis Algoritma .................................................................. 10
2.1.4 Mekanisme Pelaksanaan Algoritma .................................. 11
xi
2.1.5 Contoh Algoritma .............................................................. 13
2.2 String Matching ............................................................................. 14
2.2.1 Definisi String Matching ................................................... 14
2.2.2 Cara Kerja String Matching ............................................... 15
2.2.3 Kategori String Matching .................................................. 15
2.2.4 Macam Algoritma String Matching ................................... 16
2.3 Definisi Aplikasi ............................................................................ 25
2.4 Definisi Algoritma Searching ........................................................ 25
2.5 Sistem Berkas ................................................................................ 25
2.5.1 Definisi Sistem Berkas ...................................................... 25
2.5.2 Konsep Berkas ................................................................... 26
2.5.3 Atribut Berkas .................................................................... 27
2.6 Media Penyimpanan Eksternal ...................................................... 29
2.7 Metode Pengembangan Sistem ...................................................... 32
2.7.1 Model-model Proses Perangkat Lunak .............................. 32
2.7.2 Perbandingan Metode Perangkat Lunak ............................ 36
2.8 Algoritma Program ........................................................................ 38
2.8.1 Pseudocode ........................................................................ 38
2.8.2 Diagram Alur (Flowchart) ................................................. 39
2.8.3 STD (State Transition Diagram) ....................................... 41
2.9 Framework .NET ........................................................................... 43
2.9.1 Pengertian Microsoft .NET Framework ............................. 43
2.9.2 Arsitektur Framework .NET .............................................. 44
2.9.3 Keuntungan Framework .NET ........................................... 47
2.10 Mono Framework .......................................................................... 48
2.11 Sekilas Tentang Visual C# ............................................................ 49
2.11.1 Pengertian C# .................................................................... 49
2.11.2 Alasan Menggunakan Bahasa C# ...................................... 50
2.11.3 Mengenal Integrated Development Environment Visual
Studio 2005 ........................................................................ 52
BAB III METODOLOGI PENELITIAN ......................................................... 54
3.1 Metode Pengumpulan Data ........................................................... 54
3.1.1 Studi Pustaka ..................................................................... 54
3.2 Metode Pengembangan Sistem ...................................................... 54
3.2.1 Fase Perencanaan Syarat-syarat ......................................... 56
3.2.2 Fase Perancangan............................................................... 56
3.2.3 Fase Konstruksi ................................................................. 56
3.2.4 Fase Implementasi ............................................................. 56
3.3 Alasan penulis menggunakan RAD ............................................... 56
xii
BAB IV PERANCANGAN DAN IMPLEMENTASI ...................................... 58
4.1 Fase Perencanaan Syarat-Syarat .................................................... 58
4.1.1 Mendefiniskan Masalah ..................................................... 58
4.1.2 Analisis Algoritma String Matching .................................. 58
4.1.3 Analisis Kebutuhan Sistem .............................................. 100
4.2 Fase Perancangan ........................................................................ 101
4.2.1 Perancangan Proses ......................................................... 101
4.2.2 Perancangan Antarmuka .................................................. 105
4.3 Fase Konstruksi ........................................................................... 111
4.4 Fase Pelaksanaan ......................................................................... 112
4.4.1 Pengujian Sistem Aplikasi Pencarian Berkas .................. 112
4.4.2 Spesifikasi Hardware dan Software ................................ 114
4.4.3 Pengenalan Tampilan....................................................... 115
4.4.4 Pengujian Algoritma String Matching ............................. 120
BAB V PENUTUP ............................................................................................ 129
5.1 Kesimpulan .................................................................................. 129
5.2 Saran ............................................................................................ 130
Daftar Pustaka ..................................................................................................... 131
Lampiran Source Code ........................................................................................ 133
xiii
DAFTAR TABEL
Daftar Tabel
Tabel 2.1 Contoh tabel bmBC ............................................................................... 23
Tabel 2.2 Simbol-simbol diagram alur.................................................................. 40
Tabel 4.1 Hasil tabel kmpNext .............................................................................. 70
Tabel 4.2 Hasil tabel bmBC .................................................................................. 83
Tabel 4.3 Hasil tabel suff ....................................................................................... 87
Tabel 4.4 Hasil tabel bmGS ................................................................................... 94
Tabel 4.5 Perbandingan algoritma string matching ............................................ 100
Tabel 4.6 Tabel fungsi combobox, checkbox dan textbox pada menu utama ...... 118
Tabel 4.7 Hasil uji coba algoritma string matching ............................................ 128
xiv
DAFTAR GAMBAR
Daftar Gambar
Gambar 2.1 Komponen-komponen utama komputer ............................................ 11
Gambar 2.2 Dua buah bejana berisi larutan yang berbeda warna ......................... 13
Gambar 2.3 Bejana tambahan ............................................................................... 14
Gambar 2.4 Contoh atribut berkas ........................................................................ 29
Gambar 2.5 Harddisk ............................................................................................ 30
Gambar 2.6 Model sekuensial linear ..................................................................... 33
Gambar 2.7 Prototipe paradigma .......................................................................... 33
Gambar 2.8 Model RAD (Rapid Application Development) ................................ 35
Gambar 2.9 Contoh perubahan state ..................................................................... 41
Gambar 2.10 Notasi Modul ................................................................................... 42
Gambar 2.11 Notasi Tampilan .............................................................................. 42
Gambar 2.12 Notasi Tindakan .............................................................................. 42
Gambar 2.13 Arsitektur framework .NET ............................................................. 45
Gambar 2.14 Splash Screen Visual Studio 2005 .................................................. 52
Gambar 2.15 Tampilan Lingkungan Visual Studio 2005 ..................................... 53
Gambar 3.1 Siklus Pengembangan Sistem Model RAD ....................................... 55
Gambar 4.1 Pencarian berkas di komputer ......................................................... 101
Gambar 4.2 Rekursi n kali .................................................................................. 102
Gambar 4.3 Flowchart algoritma pencarian berkas di komputer ....................... 104
Gambar 4.4 Flowchart bagian string matching .................................................. 105
Gambar 4.5 Rancangan form splash screen ........................................................ 106
Gambar 4.6 Rancangan STD form splash screen ............................................... 106
Gambar 4.7 Rancangan form menu utama .......................................................... 107
Gambar 4.8 Rancangan STD form menu utama ................................................. 107
Gambar 4.9 Rancangan form bantuan ................................................................. 109
Gambar 4.10 Rancangan STD form bantuan ...................................................... 109
Gambar 4.11 Rancangan form info ..................................................................... 110
Gambar 4.12 Rancangan STD form info ............................................................ 110
Gambar 4.13 Rancangan form pembuat.............................................................. 110
Gambar 4.14 Rancangan STD form pembuat ..................................................... 111
Gambar 4.15 Proses pencarian kata .................................................................... 111
Gambar 4.16 Proses pada pencarian berkas ........................................................ 112
Gambar 4.17 Tampilan proses pencarian diterima ............................................. 113
Gambar 4.18 Tampilan proses pencarian tidak diterima .................................... 114
Gambar 4.19 Tampilan form splash screen ........................................................ 115
Gambar 4.20 Tampilan form menu utama dengan .NET .................................... 116
xv
Gambar 4.21 Tampilan form menu utama dengan Mono ................................... 116
Gambar 4.22 Tampilan form bantuan ................................................................. 119
Gambar 4.23 Tampilan form info........................................................................ 119
Gambar 4.24 Tampilan form pembuat ................................................................ 120
Gambar 4.25 Informasi perangkat keras dan perangkat lunak untuk uji coba .... 121
Gambar 4.26 Keterangan drive untuk uji coba ................................................... 121
Gambar 4.27 Proses yang sedang berjalan .......................................................... 123
Gambar 4.28 Penggunaan memori untuk algoritma brute force ......................... 124
Gambar 4.29 Pemakaian CPU untuk algoritma brute force ............................... 124
Gambar 4.30 Hasil pencarian dengan algoritma brute force .............................. 125
Gambar 4.31 Penggunaan memori untuk algoritma knuth-morris-pratt ............ 125
Gambar 4.32 Pemakaian CPU untuk algoritma knuth-morris-pratt ................... 126
Gambar 4.33 Hasil uji coba dengan algoritma knuth-morris-pratt ..................... 126
Gambar 4.34 Penggunaan memori untuk algoritma boyer-moore ...................... 127
Gambar 4.35 Pemakaian CPU untuk algoritma boyer-moore ............................ 127
Gambar 4.36 Hasil uji coba dengan algoritma boyer-moore .............................. 127
xvi
DAFTAR ISTILAH
Daftar Istilah
Array Suatu tipe data terstruktur yang dapat menyimpan banyak data
dengan suatu nama yang sama dan menempati tempat di memori
yang berurutan serta bertipe data sama pula
Assembly Proses penerjemahan program yang ditulis dengan bahasa
pemograman simbol ke dalam bahasa mesin
Byte Informasi dengan panjang 8 bit
Compiler Program yang menerjemahkan serangkaian perintah ke dalam
bahasan mesin
Device Alat/perlengkapan komputer
Platform Dasar penopang sistem kerja suatu komputer
Framework .NET Sebuah komponen yang dapat ditambahkan ke sistem operasi
Microsoft Windows atau telah terintegrasi ke dalam Windows
(mulai dari Windows Server 2003 dan versi-versi terbaru)
Integer Bilangan bulat
Managed Code Kode atau program yang menggunakan .NET Framework atau
bisa dikatakan kode program yang dibangun dengan teknologi
.NET
Penyimpanan Online Media penyimpanan yang dilakukan secara online, yang
terhubung dengan Internet
Sistem Operasi Perangkat lunak sistem yang bertugas untuk melakukan control
dan manajemen perangkat keras serta operasi-operasi dasar
sistem, termasuk menjalankan software aplikasi seperti program-
program pengolah kata dan browser web
String Kumpulan karakter
1
BAB I
PENDAHULUAN
1 PENDAHULUAN
1.1 Latar Belakang Masalah
Komputer dapat digunakan sebagai alat bantu untuk menyelesaikan
masalah, namun komputer tidak dapat secara langsung menyelesaikan masalah
begitu saja. Untuk sampai pada tingkat penyelesaian masalah, komputer
memerlukan suatu rumusan langkah - langkah penyelesaian atau penyederhanaan
masalah tersebut dalam suatu instruksi.
Sekumpulan instruksi yang merupakan jalinan langkah penyelesaian
masalah dinamakan program. Setiap program yang dimasukkan ke dalam
komputer akan dijalankan oleh komputer dengan membaca instruksi - instruksi
yang diberikan agar memberikan hasil yang tepat. Instruksi - instruksi tersebut
dapat tersusun dengan rapi dan terurut dalam menyelesaikan masalah, maka
program tersebut membutuhkan sebuah algoritma.
Kata algorism berasal dari nama penulis buku Arab yang terkenal, yaitu
Abu Ja’far Muhammad Ibnu Musa Al-Khawarizmi (Al-Khuwarizmi dibaca oleh
orang Barat menjadi algorism). Perubahan dari kata algorism menjadi algorithm
muncul karena kata algorism sering dikelirukan dengan aritmatic, sehingga
akhiran –sm berubah menjadi –thm, maka lambat laun kata algorithm berangsur-
angsur dipakai sebagai perhitungan (komputasi) secara umum, sehingga
kehilangan makna aslinya. Kata algorithm, dalam bahasa Indonesia, diserap
menjadi algoritma. Definisi dari algoritma itu sendiri adalah urutan langkah-
2
langkah logis penyelesaian masalah yang tersusun secara sistematis (Munir,
2001:3).
Dalam proses penyelesaian masalah, seringkali diperlukan suatu sudut
pandang untuk memudahkan pemetaan terhadap masalah tersebut dan untuk itu
diperlukan pencarian data-data yang tepat. Pencarian (searching) merupakan
proses yang fundamental dalam bahasa pemograman. Proses pencarian adalah
proses menemukan nilai (data) tertentu di dalam sekumpulan nilai yang bertipe
sama (tipe dasar atau tipe bentukan) (Munir, 2002:1).
Dalam ilmu komputer, algoritma pencarian secara luas dapat didefinisikan
sebagai algoritma masukan dari sebuah masalah agar dapat menghasilkan solusi
dari masalah tersebut, yang bisanya didapat dari evaluasi beberapa kemungkinan
solusi. Himpunan semua kemungkinan solusi dari sebuah masalah itu disebut
ruang pencarian (http://id.wikipedia.org).
Pencarian string yang juga bisa disebut pencocokan string (string matching)
merupakan algoritma untuk melakukan pencarian semua kemunculan string
pendek pattern[0..n – 1] yang disebut pattern di string yang lebih panjang
teks[0..m – 1] yang disebut teks (Charras, 1997:11).
Berkas (file) merupakan sekumpulan record dari tipe tunggal yang berisi
elemen-elemen data yang menggambarkan himpunan entitas (Handayani, 2001:3).
3
Berdasarkan narasi yang telah dipaparkan, maka dapat dipahami bahwa
komputer dapat melakukan pencarian berkas di dalam sistem berkas yang telah
tersusun dengan menggunakan algoritma pencocokan string. Oleh karena itulah,
skripsi dengan judul “Analisis dan Penerapan Algoritma String Matching pada
Pencarian Berkas di Komputer” merupakan masalah yang layak mendapat
perhatian untuk dipaparkan dalam skripsi ini.
1.2 Perumusan Masalah
Berdasarkan inti dari penulisan skripsi ini, maka permasalahan yang ada
dapat penulis simpulkan sebagai berikut :
1. Bagaimana menerapkan algoritma string matching untuk mencari
sebuah berkas di komputer ?
2. Bagaimana merancang program untuk aplikasi pencarian berkas di
komputer ?
1.3 Batasan Masalah
Agar masalah tidak terlalu luas sehingga hasil yang optimal dapat dicapai,
maka penulis akan membatasi ruang lingkup pembahasan sebagai berikut :
1. Penulis menggunakan 3 (tiga) buah algoritma dari string matching, yaitu
algoritma brute force, algoritma knuth-morris-pratt dan algoritma
boyer-moore.
2. Pembuatan aplikasi ini hanya untuk mencari sebagian kata dari suatu file
atau folder di dalam sistem berkas suatu komputer.
4
3. Pembuatan aplikasi ini dilakukan dengan menggunakan Visual Studio
2005 dengan bahasa pemograman C#.
4. Pengimplementasian program ini hanya berjalan pada sistem operasi
Microsoft Windows yang sudah terinstall .NET Framework versi 2.0
atau Mono Framework versi 2.0.1.
1.4 Tujuan Penelitian
Tujuan yang ingin dicapai dalam penulisan skripsi ini yaitu:
1. Menerapkan suatu algoritma dalam hal ini algoritma string matching
untuk pembuatan suatu aplikasi.
2. Mengetahui perbandingan kinerja dari algoritma brute force, algoritma
knuth-morris-pratt dan algoritma boyer-moore.
3. Tersedianya aplikasi untuk mempermudah pencarian berkas di
komputer.
1.5 Manfaat Penelitian
Sesuai dengan permasalahan dan tujuan penelitian yang disebutkan di atas.
Banyak manfaat yang bisa penulis petik dalam pembuatan skripsi ini, diantaranya
adalah sebagai berikut:
1.5.1 Bagi Penulis
1. Untuk memenuhi salah satu syarat dalam menempuh gelar S1 (Strata 1)
pada Fakultas Sains dan Teknologi Program Studi Teknik Informatika
Universitas Islam Negeri Syarif Hidayatullah Jakarta.
5
2. Bisa menerapkan ilmu-ilmu yang diperoleh selama proses kuliah.
3. Menambah wawasan penulis tentang algoritma string matching.
4. Menambah wawasan penulis tentang penerapan serta pembuatan
perangkat lunak dari suatu algoritma.
1.5.2 Bagi Universitas
1. Mengetahui kemampuan mahasiswa dalam menguasai materi teori yang
telah diperoleh selama masa kuliah.
2. Mengetahui kemampuan mahasiswa dalam menerapkan ilmunya dan
sebagai bahan evaluasi.
1.5.3 Bagi Pengguna
1. Mengetahui cara kerja algoritma string matching dengan penerapan
suatu aplikasi pencarian berkas di komputer.
2. Dapat membandingkan algoritma apa yang lebih efektif dan efisien
untuk mencari suatu string.
1.6 Metodologi Penelitian
1.6.1 Metode Pengumpulan Data
1.6.1.1 Metode Studi Pustaka
Metode studi pustaka dilakukan dengan mengumpulkan data dan informasi
yang dijadikan sebagai acuan untuk analisis dan penerapan algoritma string
matching pada aplikasi pencarian berkas di komputer. Referensi tersebut berasal
dari buku-buku pegangan maupun publikasi hasil penelitian yang berhubungan
dengan algoritma string matching, metode pengembangan sistem metode RAD
6
(Rapid Application Development), serta bahasa pemograman visual C# sebagai
tools pengembang aplikasi.
1.6.2 Metode Pengembangan Sistem
Pengembangan sistem dalam penelitian ini yaitu menggunakan model
pengembangan sistem RAD (Rapid Application Development). RAD pertama kali
diformulasikan oleh James Martin pada tahun 1991. Penulis menerapkan 4
(empat) tahap siklus pengembangan RAD (Kendall & Kendall, 2003:237), yaitu:
1. Fase Menentukan Tujuan dan Syarat-Syarat Informasi
Pada tahap ini dilakukan pengidentifikasian tujuan-tujuan aplikasi atau
sistem serta untuk mengidentifikasi syarat-syarat informasi yang
ditimbulkan dari tujuan-tujuan tersebut.
2. Fase Perencanaan
Pada tahap ini akan dilakukan perancangan proses yaitu perancangan
proses-proses yang akan terjadi di dalam sistem, perancangan antarmuka
yaitu perancangan antarmuka masukan dan antarmuka keluaran.
3. Fase Konstruksi
Pada tahap ini akan dilakukan pengkodean terhadap rancangan-
rancangan yang telah didefinisikan.
4. Fase Pelaksanaan
Pada tahap ini dilakukan pengujian masing-masing modul (unit)
program, apakah sesuai dengan tugasnya kemudian dilakukan uji coba
terhadap integrasi keseluruhan unit program untuk mengetahui apakah
sistem yang telah dibuat sudah memenuhi kriteria yang diinginkan.
7
1.7 Sistematika Penulisan
Dalam penulisan skripsi ini dibagi menjadi 5 (lima) bab dengan beberapa
sub bab pokok bahasan. Adapun sistematika dari skripsi ini adalah sebagai
berikut:
BAB I PENDAHULUAN
Bab ini akan diuraikan mengenai latar belakang, rumusan masalah,
batasan masalah, tujaun penelitian, manfaat penelitian, metodologi
penelitian dan sistematika penulisan.
BAB II LANDASAN TEORI
Bab ini menguraikan secara singkat teori-teori yang digunakan
dalam membantu penulisan skripsi mengenai Analisis dan
Penerapan Algoritma String Matching pada Aplikasi Pencarian
Berkas di Komputer.
BAB III METODOLOGI PENELITIAN
Bab ini menguraikan metode penelitian yang digunakan dalam
menganalisis, merancang dan mengimplementasian sistem.
BAB IV PEMBAHASAN DAN IMPLEMENTASI
Pada bab ini akan dijelaskan proses penelitian penulis dalam
merancang dan membangun sistem pencarian berkas di komputer
meliputi fase menentukan syarat-syarat, fase perancangan, fase
konstruksi dan fase pelaksanaan.
8
BAB V PENUTUP
Dalam bab ini berisi uraian tentang kesimpulan-kesimpulan yang
didapat serta mengemukakan saran yang dianggap perlu.
9
BAB II
LANDASAN TEORI
2 LANDASAN TEORI
2.1 Algoritma
2.1.1 Definisi Algoritma
Algoritma merupakan urutan langkah-langkah logis penyelesaian masalah
yang disusun secara sistematis (Munir, 2001:4).
Sebagai pembanding, definisi kata algoritma menurut Kamus Besar Bahasa
Indonesia terbitan Balai Pustaka 1988 :
Algoritma merupakan urutan logis pengambilan keputusan untuk
pemecahan masalah.
2.1.2 Ciri Algoritma
Menurut Donald E. Knuth dalam bukunya yang berjudul The Art of
Computer Programming, algoritma harus mempunyai lima ciri penting (Munir,
2001:5) :
1. Algoritma memiliki nol atau lebih masukan dari luar (input)
2. Algoritma mempunyai nol atau lebih keluaran (output)
3. Algoritma memiliki intruksi-instruksi yang jelas dan tidak ambigu
(definiteness)
4. Algoritma harus berhenti setelah mengerjakan sejumlah langkah terbatas
(finiteness)
10
5. Algoritma sebisa mungkin harus dapat dilaksanakan dan efektif
(effectiveness). Contoh instruksi yang tidak efektif adalah A = A + 0
atau A = A * 1
2.1.3 Jenis Algoritma
Terdapat beragam klasifikasi algoritma dan setiap klasifikasi mempunyai
alasan tersendiri. Salah satu cara untuk melakukan klasifikasi jenis-jenis algoritma
adalah dengan memperhatikan paradigma dan metode yang digunakan untuk
mendesain algoritma tersebut. Beberapa paradigma yang digunakan dalam
menyusun suatu algoritma, sebagai berikut (Hertono, 1998:21) :
1. Divide and Conquer
Suatu teknik yang melakukan dekomposisi dari masalah utama, dan
menyelesaikan masalah tersebut dengan cara menyelesaikan sub-sub
masalah yang sejenis dengan masalah utama, dan menggabungkan
solusi-solusi dari sub masalah untuk mendapatkan solusi masalah utama.
2. Dynamic Programming
Teknik dynamic programming memiliki prinsip yang sama dengan
devide and conqueror, dimana keduanya menyelesaikan suatu masalah
dengan cara memecahnya menjadi sub-sub masalah yang dapat
diselesaikan secara rekursif. Meskipun demikian, pada dynamic
programming diusahakan menghindari dilakukannya redudansi proses
suatu sub masalah (selama proses rekursif), yakni dengan cara mencatat
hasil yang telah diperoleh dari suatu sub masalah pada suatu tabel,
dengan demikian untuk proses sub masalah lain yang lebih besar, tidak
11
perlu menghitung berulang-ulang nilai sub masalah yang lebih kecil
yang pernah dihitung sebelumnya.
3. Greedy
Sebuah paradigma greedy mirip dengan sebuh algoritma dynamic
programming, bedanya jawaban dari sub masalah tidak perlu diketahui
dalam setiap tahap dan menggunakan pilihan “serakah” apa yang dilihat
terbaik pada saat itu. Teknik algoritma ini biasanya digunakan untuk
masalah-masalah optimasi, seperti job scheduling, shortest path pada
graph.
Dalam hal ini algoritma string matching atau pencocokkan string termasuk
ke dalam jenis algoritma dynamic programming.
2.1.4 Mekanisme Pelaksanaan Algoritma
Secara garis besar komputer tersusun atas 4 (empat) komponen utama, yiatu
(Munir, 2001:9) :
Piranti MasukanUnit Pemroses
Utama (CPU)Piranti Keluaran
Memori
Gambar 2.1 Komponen-komponen utama komputer
12
1. Piranti masukan
Tahap ini merupakan proses pemasukkan data ke dalam proses
komputer lewat piranti masukan. Contohnya keyboard, mouse, dan lain-
lain.
2. Piranti keluaran
Tahap ini merupakan proses menghasilkan keluaran (output) dari hasil
unit pemroses utama ke piranti keluaran, yaitu berupa informasi.
Contohnya monitor, printer, dan lain-lain.
3. Unit pemroses utama (CPU)
Merupakan “otak” komputer, yang berfungsi mengerjakan operasi-
operasi dasar seperti operasi perbandingan, operasi perhitungan, operasi
membaca dan operasi menulis.
4. Memori
Komponen yang berfungsi menyimpan atau mengingat-ingat.
Mekanisme kerja keempat komponen pada gambar 2.1 dapat dijelaskan
sebagai berikut. Mula-mula program dimasukkan ke dalam memori komputer.
Ketika program dilaksanakan (execute), setiap instruksi yang telah tersimpan di
dalam memori dikirim ke CPU. CPU mengerjakan operasi-operasi yang
bersesuaian dengan instruksi tersebut. Bila suatu operasi memerlukan data, data
dibaca dari piranti masukan, disimpan di dalam memori, lalu dikirim ke CPU
untuk operasi yang memerlukannya. Bila proses menghasilkan keluaran atau
informasi, keluaran disimpan ke dalam memori, lalu memori menuliskan keluaran
tadi ke piranti keluaran.
13
2.1.5 Contoh Algoritma
Tinjau persoalan mempertukarkan isi dua buah bejana, A dan B. Bejana A
berisi larutan yang berwarna merah, sedangkan bejana B berisi air berwarna biru
(gambar 2.2). Kita akan mempertukarkan isi kedua bejana itu sedemikian
sehingga A berisi larutan berwarna biru dan bejana B berisi larutan berwarna
merah.
Seseorang menuliskan langkah-langkah pertukaran isi kedua berjana
tersebut dengan algoritma TUKAR ISI BEJANA sebagai berikut :
Algoritma TUKAR_ISI_BEJANA
Diberikan dua buah bejana, A dan B; bejana A berisi larutan
berwarna merah, bejana B berisi larutan berwarna biru. Pertukarkan
isi kedua bejana itu sedemikian sehingga bejana A berisi larutan
berwarna biru dan bejana B berisi larutan berwarna merah.
DESKRIPSI
1. Tuangkan larutan dari bejana A ke dalam bejana B 2. Tuangkan larutan dari bejana B ke dalam bejana A
Bejana A Bejana B
Gambar 2.2 Dua buah bejana berisi larutan yang berbeda warna
Algoritma TUKAR ISI BEJANA yang telah dijelaskan tidak menghasilkan
pertukaran yang benar, langkah-langkahnya tidak logis. Alih-alih
mempertukarkan, yang terjadi adalah percampuran keduanya. Jadi, algoritma
TUKAR ISI BEJANA tersebut adalah salah.
Untuk mempertukarkan isi dua buah bejana, kita memerlukan sebuah bejana
tambahan yang diperlukan sebagai tempat penampungan sementara. Sebut saja
14
bejana tambahan tersebut bejana C (gambar 2.3), dengan menggunakan bejana
bantu C ini, algoritma mempertukarkan isi dua buah bejana yang benar adalah
sebagai berikut ini :
Algoritma TUKAR_ISI_BEJANA
Diberikan dua buah bejana, A dan B; bejana A berisi larutan
berwarna merah, bejana B berisi larutan berwarna biru. Pertukarkan
isi kedua bejana itu sedemikian sehingga bejana A berisi larutan
berwarna biru dan bejana B berisi larutan berwarna merah.
DESKRIPSI
1. Tuangkan larutan dari bejana A ke dalam bejana C 2. Tuangkan larutan dari bejana B ke dalam bejana A 3. Tuangkan larutan dari bejana C ke dalam bejana B
Bejana A Bejana B Bejana C
Gambar 2.3 Bejana tambahan
Sekarang, dengan algoritma TUKAR ISI BEJANA yang sudah diperbaiki,
isi bejana A dan bejana B dipertukarkan dengan benar. Pada akhir algoritma,
bejana A berisi larutan berwarna biru dan bejana B berisi larutan berwarna merah.
2.2 String Matching
2.2.1 Definisi String Matching
Pencarian string yang juga bisa disebut pencocokan string (string
matching) merupakan algoritma untuk melakukan pencarian semua kemunculan
string pendek pattern[0..n - 1] yang disebut pattern di string yang lebih panjang
teks[0..m -1] yang disebut teks (Charras, 1997:11).
15
2.2.2 Cara Kerja String Matching
Persoalan pencarian string dirumuskan sebagai berikut (Munir, 2004:1) :
1. Teks (text), yaitu (long) string yang panjangnya m karakter
2. Pattern, yaitu string dengan panjang n karakter (n < m) yang akan dicari
di dalam teks.
Sebagai contoh, carilah (find atau locate) lokasi pertama di dalam teks yang
bersesuaian dengan pattern. Aplikasi dari masalah string matching antara lain
pencarian suatu kata di dalam dokumen (misalnya menu Find di dalam Microsoft
Word).
2.2.3 Kategori String Matching
Algoritma string matching dapat diklasifikasian menjadi 3 (tiga) bagian
menurut arah pencariannya, yakni (Charras, 1997:12) :
1. From left to right
Dari arah yang paling alami, dari kiri ke kanan, yang merupakan arah
untuk membaca. Algoritma yang termasuk kategori ini adalah algoritma
brute force, algoritma knuth-morris-pratt.
2. From right to left
Dari arah kanan ke kiri, arah yang bisanya menghasilkan hasil terbaik
secara praktikal. Algoritma yang termasuk kategori ini adalah algoritma
boyer-moore.
16
3. In a specific order
Dari arah yang ditentukan secara spesifik oleh algoritma tersebut, arah
ini menghasilkan hasil terbaik secara teoritis. Algoritma yang termasuk
kategori ini adalah algoritma colossi dan algoritma crochemore-perrin.
2.2.4 Macam Algoritma String Matching
2.2.4.1 Algoritma Brute Force
Algoritma brute force atau naïve algorithm merupakan algoritma string
matching yang ditulis tanpa memikirkan peningkatan performa. Algoritma brute
force memecahkan masalah dengan sangat sederhana, langsung dan dengan cara
yang jelas (Sedgewick, 1984:243).
Cara kerja algoritma brute force, sebagai berikut (Munir, 2004:2) :
1. Algoritma brute force mulai mencocokkan pattern pada awal teks
2. Dari kiri ke kanan, algoritma brute force akan mencocokkan karakter
per karakter pattern dengan karakter di teks yang bersesuaian, sampai
salah satu kondisi berikut dipenuhi :
1) Karakter di pattern dan teks dibandingkan tidak cocok (mismatch)
2) Semua karakter di pattern cocok. Kemudian algoritma akan
memberitahukan penemuan di posisi ini
3. Algoritma kemudian terus menggeser pattern sebesar satu ke kanan, dan
mengulangi langkah ke-2 sampai pattern berada di ujung teks
Pseudocode algoritma brute force sebagai berikut :
1. function BruteForceSearch(
2. input n : integer, { panjang pattern }
3. input m : integer, { panjang teks }
4. input P : string, { string pattern }
5. input T : string, { string teks }
17
6. ) boolean
7.
8. Deklarasi
9. i : integer { pointer dari teks }
10. j : integer { ponter dari pattern }
11. ketemu : boolean { menampung nilai ketemu }
12.
13. Algoritma
14. i := 0
15. ketemu := false
16. while ( i <= m – n) do
17. j := 0
18. while (j < n) and (T[i + j] == P[j]) do
19. j := j + 1
20. endwhile
21. if j >= n then
22. ketemu := true
23. endif
24. i := i + 1
25. endwhile
26. return ketemu
2.2.4.2 Algoritma Knuth-Morris-Pratt
Algoritma knuth-morris-pratt merupakan salah satu algoritma pencarian
string yang dikembangkan secara terpisah oleh Donald R. Knuth pada tahun 1967
dan James H. Morris bersama Vaughan R. Pratt pada tahun 1966, namun
keduanya mempublikasikan secara bersamaan pada tahun 1977 (Sedgewick,
1984:242).
Jika pada algoritma brute force karakter pada teks dibandingkan satu
persatu, setiap tidak cocok bergeser 1 karakter ke kanan, maka pada algoritma
knuth-morris-pratt informasi yang digunakan untuk melakukan jumlah pergeseran
karakter disimpan pada tabel kmpNext. Sehingga pergeseran akan dilakukan
berdasarkan informasi tersebut, akibatnya waktu proses dapat berkurang.
Cara kerja algoritma knuth-morris-pratt, sebagai berikut
(http://id.wikipedia.org/) :
18
1. Algoritma knuth-morris-pratt mulai mencocokkan pattern pada awal
teks
2. Dari kiri ke kanan, algoritma knuth-morris-pratt akan mecocokkan
karakter per karakter dengan karakter di teks yang bersesuaian, sampai
salah satu kondisi berikut dipenuhi :
1) Karakter di pattern dan di teks yang dibandingkan tidak cocok
(mismatch)
2) Semua katakter di pattern cocok. Kemudian algoritma ini akan
memberitahukan di posisi ini
3. Algoritma kemudian menggeser pattern berdasarkan fungsi pinggiran /
tabel kmpNext, lalu mengulangi langkah 2 sampai pattern berada di
ujung teks
Pseudocode algoritma knuth-morris-pratt sebagai berikut :
1. function KMPSearch(
2. input n : integer, { panjang pattern }
3. input m : integer, { panjang teks }
4. input P : string, { string pattern }
5. input T : string, { string teks }
6. ) boolean
7.
8. Deklarasi
9. i : integer { pointer dari teks }
10. j : integer { pointer dari pattern }
11. next : integer { menampung jumlah pergeseran }
12. ketemu : boolean { menampung nilai ketemu }
13. kmpNext : array[1..n] of integer
14. procedure HitungPinggiran(input n : integer, P : string,
output kmpNext : array[1..n] of integer)
15.
16. Algoritma
17. HitungPinggiran(m, P, kmpNext)
18. i := 0
19. next := 1
20. ketemu := false
21. while (i <= m - n) do
22. j := 0
23. while((j < n) and (T[i + j] == P[j])) do
24. j := j + 1
19
25. endwhile
26. if j >= n then
27. ketemu := true
28. next := j
29. else
30. next := j - kmpNext[j]
31. endif
32. i := i + next
33. endwhile
34. return ketemu
Fungsi Pinggiran (Border Function)
Algoritma knuth-morris-pratt melakukan proses awal (preprocessing)
terhadap pattern P dengan menghitung fungsi pinggiran. Pada beberapa literatur
disebut fungsi overlap, fungsi failure, fungsi awalan dan sebagainya. Fungsi ini
mengindikasikan pergeseran P terbesar yang mungkin dengan menggunakan
perbandingan yang dibentuk sebelum pencarian string.
Fungsi pinggiran kmpNext(j) didefinisikan sebagai ukuran awalan
terpanjang dari P yang merupakan akhiran dari P[1..j] (Munir, 2004:8). Fungsi
pinggiran dihitung hanya berdasarkan kepada karakter-karakter dalam pattern,
tidak menyertakan karakter-karakter dalam teks (string target).
Pseudocode fungsi pinggiran untuk algoritma knuth-morris-pratt sebagai
berikut :
1. procedure HitungPinggiran(
2. input n : integer, { panjang pattern }
3. input P : string, { string pattern }
4. output kmpNext : array [1..n] of integer { tabel
kmpNext }
5. )
6.
7. Deklarasi
8. i : integer
9. j : integer
10.
11. Algoritma
12. i := 0
13. j := -1
14. kmpNext[0] := -1
15. while(i < n - 1)
20
16. while ((j >= 0) and (P[i] ≠ P[j]))
17. j := kmpNext[j]
18. endwhile
19. i := i + 1
20. j := j + 1
21. if(P[i] = P[j])
22. kmpNext[i] := kmpNext[j]
23. else
24. kmpNext[i] := j
25. endif
26. endwhile
2.2.4.3 Algoritma Boyer-Moore
Algoritma boyer-moore merupakan salah satu algoritma pencarian string
yang dipublikasikan oleh Robert S. Boyer dan J. Strother Moore pada tahun 1977
(Sedgewick, 1984:242).
Algoritma boyer-moore prinsipnya mirip dengan algoritma knuth-morris-
pratt, yaitu menyimpan informasi pergeseran untuk melakukan pencarian string.
Perbedaannya dengan algoritma knuth-morris-pratt adalah jika algoritma knuth-
morris-pratt membandingkan string mulai dari pattern sebelah kiri (depan), maka
algoritma boyer-moore melakukannya dari sebelah kanan (belakang).
Keuntungan membandingkan mulai dari sebelah kanan (belakang) adalah
ketidakcocokkan saat membandingkan string akan membuat pergerakan pattern
melompat lebih jauh untuk menghindari perbadingan karakter pada string yang
diperkirakan akan gagal.
Secara sistematis, langkah-langkah yang dilakukan algoritma boyer-moore
pada saat mencocokkan string adalah sebagai berikut (http://id.wikipedia.org/) :
1. Algoritma boyer-moore mulai mencocokkan pattern pada awal teks.
21
2. Dari kanan ke kiri, algoritma ini akan mencocokkan karakter per
karakter pattern dengan karakter di teks yang bersesuaian, sampai salah
satu kondisi berikut dipenuhi
1) Karakter di pattern dan di teks yang dibandingkan tidak cocok
(mismatch)
2) Semua karakter di pattern cocok. Kemudian algoritma akan
memberitahukan penemuan di posisi ini.
3. Algoritma kemudian menggeser pattern dengan memaksimalkan nilai
good-suffix dan pergeseran bad-character, lalu mengulangi langkah 2
sampai pattern berada di ujung teks
Pseudocode algoritma Boyer-Moore sebagai berikut :
1. function BMSearch(
2. input n : integer, { panjang pattern }
3. input m : integer, { panjang teks }
4. input P : string, { string pattern }
5. input T :string { string teks }
6. ) boolean
7.
8. Deklarasi
9. i : integer { pointer dari teks }
10. j : integer { pointer dari pattern }
11. bmBCShift : integer { temp jumlah pergeseran bad-
character }
12. bmGSShift : integer { temp jumlah pergeseran good-
suffix }
13. shift : integer { temp pergeseran }
14. ketemu : boolean { temp ketemu }
15. bmBC : array[0..ASIZE] of integer { temp tabel bmBC }
16. bmGS : array[0..n-1] of integer { temp tabel bmGS }
17. procedure BadCharacter(input P : string, input n :
integer, output bmBC : array[0..n-1] of integer)
18. procedure GoodSuffix(input P : string, input n :
integer, output bmGS : array[0..n-1] of integer)
19.
20. Algoritma
21. BadCharacter(P, n, bmBC)
22. GoodSuffix(P, n, bmGS)
23. i := 0
24. ketemu := false
25. while (i <= m-n) do
22
26. j := n-1
27. while(j >= 0 and T[i+j] == P[j])
28. j := j-1
29. endwhile
30. if(j < 0) then
31. ketemu := true
32. i := i+ bmGS[0]
33. else
34. bmBCShift := bmBC[T[i+j]] - n + 1 + j
35. bmGSShift := bmGS[j]
36. shift := max(bmBCShift, bmGSShift)
37. i := i + shift
38. endif
39. endwhile
40. return ketemu
Bad-Character Shift Rule
Aturan bad-character shift dibutuhkan untuk menghindari pengulangan
perbandingan yang gagal dari suatu karakter dalam target teks dengan pattern.
Besarnya pergeseran yang dilakukan dalam aturan bad-character shift disimpan
dalam bentuk tabel yang dapat kita namakan tabel bmBC, tabel ini terdiri dari dua
kolom yaitu kolom karakter dan kolom shift yang menunjukkan besarnya
pergeseran yang harus dilakukan.
Proses kalkulasi untuk pengisian tabel bmBC ini adalah dengan cara
memberikan indeks angka kepada setiap karakter dalam pattern. Indeks 0
diberikan pada karakter terakhir/paling kanan dari pattern, kemudian bergerak ke
kiri, semakin kekiri indeks dinaikkan 1 sampai pada karakter pertama pada
pattern dan apabila karakter pada posisi tersebut belum ada maka karakter
tersebut dimasukkan pada tabel bmBC dengan nilai pada kolom shift yang
disesuaikan dengan indeks.
Contoh : untuk suatu pattern “WIKIPEDIA” maka tabel bmBC-nya akan
seperti Tabel 2.1 berikut ini :
23
Tabel 2.1 Contoh tabel bmBC
Karakter Shift
I 1
D 2
E 3
P 4
K 6
W 8
Pseudocode bad-character shift rule untuk algoritma boyer-moore sebagai
berikut :
1. procedure BadCharacter(
2. input P : string, { string pattern }
3. input n : integer, { panjang pattern }
4. output bmBC : array[0..n-1] of integer { tabel bmBC }
5. )
6.
7. Deklarasi
8. i : integer { pointer untuk awal tabel bmBC }
9. j : integer { pointer untuk akhir tabel bmBC }
10.
11. Algoritma
12. for(i := 0 to ASIZE-1)
13. bmBC[i] := -1;
14. endfor
15. for(j := 0 to n-1)
16. bmBC[P[j]] := n - j – 1
17. endfor
Good Suffix Shift Rule
Good suffix rule digunakan untuk menghitung banyaknya pergeseran yang
harus dilakukan, tetapi berdasarkan jumlah karakter yang berhasil dicocokkan
sebelum pencocokkan string tersebut gagal.
Pseudocode suffix untuk good suffix shift rule sebagai berikut :
1. procedure Suffix (
2. input P : string, { string pattern }
3. input n : integer, { panjang pattern }
4. output suff : array[0..n-1] of integer { tabel suff }
5. )
6.
24
7. Deklarasi
8. f : integer { pointer suffix pattern }
9. g : integer { pointer pajang suffix pattern }
10. j : integer { pointer dari pattern }
11.
12. Algoritma
13. suff[n-1] := n
14. f := 0
15. g := n - 1
16. for(j := n - 2 downto 0)
17. if(j > g and (suff[j + n - 1 - f] < j - g))
18. suff[j] := suff[j + n - 1 - f]
19. else
20. if(j < g)
21. g := j
22. endif
23. f := j
24. while(g >= 0 and P[g] == P[g + n - 1 - f])
25. --g
26. endwhile
27. suff[j] := f - g
28. endif
29. endfor
Pseudocode GoodSuffix untuk algoritma boyer-moore sebagai berikut :
1. procedure GoodSuffix(
2. input P : string, { string pattern }
3. input n : integer, { panjang pattern }
4. output bmGS : array[0..n-1] of integer { tabel bmGS }
5. )
6.
7. Deklarasi
8. i : integer { pointer pattern }
9. j : integer { pointer untuk bmGS }
10. suff : array[0..n-1] of integer { temp suff }
11. procedure Suffix(input P : string, input n : integer,
output suff : array[1..n] of integer)
12.
13. Algoritma
14. Suffix(P, n, suff)
15. for(i := 0 to n - 1)
16. bmGS[i] := n
17. endfor
18. j := 0
19. for(i := n -1 downto -1)
20. if(i == -1 or suff[i] == i + 1)
21. for(j := 0 to n - 2 - i )
22. if(bmGS[j] = n)
23. bmGS[j] := n - 1 - i
24. endif
25. endfor
26. endif
27. endfor
28. for(i := 0 to n - 2)
29. bmGS[n - 1 - suff[i]] := n - 1 – i
25
30. endfor
2.3 Definisi Aplikasi
Perangkat lunak aplikasi adalah subkelas perangkat lunak komputer yang
memanfaatkan kemampuan komputer langsung untuk melakukan suatu tugas yang
diinginkan pengguna. Biasanya dibangdingkan dengan perangkat lunak sistem
yang mengintegrasikan berbagai kemampuan komputer, tapi tidak secara langsung
menerapkan kemampuan tersebut untuk mengerjakan suatu tugas yang
menguntungkan pengguna (http://id.wikipedia.org/). Contoh perangkat lunak
aplikasi adalah pengolah kata, lembar kerja, pemutar media dan lain-lain.
2.4 Definisi Algoritma Searching
Dalam ilmu komputer, sebuah algoritma pencarian dijelaskan secara luas
adalah sebuah algoritma yang menerima masukan berupa sebuah masalah dan
menghasilkan sebuah solusi untuk masalah tersebut, yang biasanya didapat dari
evaluasi beberapa kemungkinan solusi (http://id.wikipedia.org/).
2.5 Sistem Berkas
2.5.1 Definisi Sistem Berkas
Sistem berasal dari bahasa Latin (systema) dan bahasa Yunani (sustema)
adalah suatu kesatuan yang terdiri dari komponen atau elemen yang dihubungkan
bersama untuk mempermudah aliran informasi (http://id.wikipedia.org/).
26
Berkas komputer atau berkas adalah entitas dari data yang tersimpan di
dalam sistem berkas yang dapat diakses dan diatur oleh pengguna
(http://id.wikipedia.org/).
Sistem berkas atau pengarsipan merupakan suatu sistem untuk mengetahui
bagaimana cara menyimpan data dari file tertentu dan organisasi file yang
digunakan (Handayani, 2001:1).
Sistem berkas merupakan aspek yang paling terlihat dari sebuah sistem
operasi. Sistem berkas menyediakan mekanisme untuk penyimpanan online dan
akses ke data dan program. Sistem berkas terbagi menjadi dua bagian yang jelas,
yaitu (Handayani, 2001:1) :
1. Koleksi berkas (masing-masing menyimpan data yang berkaitan)
2. Struktur direktori (mengatur dan menyediakan informasi mengenai
semua berkas yang berada di sistem operasi).
2.5.2 Konsep Berkas
Berkas adalah sebuah koleksi informasi berkaitan yang diberi nama dan
disimpan di dalam media penyimpanan eksternal. Bisanya sebuah berkas
merepresentasikan data atau program. Adapun jenis - jenis dari berkas, yaitu
(MDGR, 2005:297) :
1. Text file
Ukuran dari karakter-karakter yang diatur menjadi barisan dan mungkin
halaman.
27
2. Source file
Urutan dari subroutine dan fungsi yang masing-masing kemudian diatur
sebagai deklarasi-deklarasi diikuti pernyataan-pernyataan yang dapat di
jalankan (execute).
3. Object file
Urutan dari beberapa byte yang diatur menjadi blok-blok yang dapat
dipahami oleh penghubung sistem.
4. Executable file
Kumpulan dari bagian-bagian kode yang dapat dibawa ke memori dan
dijalankan oleh loader.
2.5.3 Atribut Berkas
Selain nama dan data, sebuah berkas dikaitkan dengan informasi - informasi
tertentu yang juga penting untuk dilihat pengguna, seperti kapan berkas itu dibuat,
ukuran berkas, dan lain-lain. Setiap sistem operasi mempunyai atribut yang
berbeda-beda, namun pada dasarnya memiliki atribut-atribut dasar seperti berikut
ini (MDGR, 2005:297) :
1. Nama
Nama berkas simbolik ini adalah informasi satu-satunya yang disimpan
dalam format yang dibaca oleh pengguna.
2. Identifier
Tanda unik ini yang bisanya merupakan sebuah angka, mengenali berkas
di dalam sebuah sistem berkas, tidak dapat dibaca pengguna.
28
3. Jenis
Informasi ini diperlukan untuk sistem-sistem yang mendukung jenis
berkas yang berbeda.
4. Lokasi
Informasi ini adalah sebuah penunjuk pada sebuah device dan pada
lokasi berkas pada device tersebut.
5. Ukuran
Ukuran dari sebuah berkas (dalam bytes, words atau blocks) dan
mungkin ukuran maksimum dimasukkan dalam atribut ini juga.
6. Proteksi
Proteksi yang menentukan siapa yang dapat melakukan read, write,
execute, dan lainnya pada berkas.
7. Waktu dan identifikasi pengguna
Informasi ini dapat disimpan untuk pembuatan berkas, modifikasi
terakhir, dan pengguna terakhir. Data-data ini dapat berguna untuk
proteksi, keamanan, dan monitoring penggunaan.
29
Gambar 2.4 Contoh atribut berkas
2.6 Media Penyimpanan Eksternal
Penyimpanan eksternal (secondary storage atau external storage) adalah
peranti yang dapat menyimpan data secara permanen. Data tidak hilang ketika
komputer dimatikan (Kadir, 2005:180).
Nama file atau folder bisa dicari pada media penyimpanan eksternal yang
tertera sebagai berikut :
1. Harddisk
Harddisk merupakan salah satu jenis piringan magnetik yang memiliki
kapasitas yang besar. Harddisk memiliki piringan metal yang dilapisi
dengan bahan yang memungkinkan data dapat disimpan dalam bentuk
titik-titik bermagnet. Data disimpan pada kedua permukaan. Piringan-
piringan yang menyusun harddisk tersimpan rapat dalam harddrive.
Tujuannya adalah untuk melindungi dari partikel debu atau benda kecil
30
lain yang mengotori piringan sehingga tidak terjadi tabrakan antara head
dan piringan, yang dapat menimbulkan kerusakan.
Gambar 2.5 Harddisk
Data dibaca atau ditulis melalui head baca/tulis. Ketika berlangsung
perekaman atau pembacaan, head bergerak ke lokasi data dan melayang
di atas piringan tanpa menyentuhnya. Kecepatan akses data pada
piringan ditentukan oleh kecepatan putar piringan dan kecepatan lengan
akses. Kecepatan putar piringan berkisar antara 3500 rpm (rotasi per
menit) sampai dengan 7000 rpm.
2. Floppy Disk
Disket (floppy disk atau magnetic diskette atau flexible disk) diciptakan
dengan tujuan agar data dapat dipindahkan dari suatu komputer ke
komputer yang lain. Oleh karena sifatnya yang demikian, disket bisa
juga disebut removable disk. Disket berisi sebuah piringan magnetik.
Pembacaan dan penulisan data ke piringan magnetik dilakukan melaui
head yang akan menempel ke permukaan piringan.
31
Disket yang umum pada saat ini adalah yang berukuran 3,5 inci
(diameter piringan) dengan kapasitas 1,44 MB. Pada masa sebelumnya,
terdapat pula disket berukuran 5,25 inci dengan kapasitas 1,2 MB.
3. Zip Disk
Di lingkungan PC (Personal Computer) terdapat piranti yang sifatnya
seperti disket dalam arti bisa dibawa-bawa, tetapi memiliki kapasitas
yang lebih tinggi. Piranti ini dihubungkan ke komputer melalui port
printer, port USB (Universal Serial Bus) maupun port SCSI (Small
Computer System Interface). Media ini memiliki kapasitas 250 MB
untuk dihubungkan ke port parallel atau SCSI dan 750 MB untuk
dihubungkan ke port USB. Ukurannya sedikit lebih besar dibandingkan
dengan disket dan dengan ketebalan dua kali.
4. Piringan Optik
Merupakan media penyimpanan data optical disk berbentuk piringan
dengan kapasitas penyimpanan data besar. Yang paling sering dipakai
adalah CD-R (recodable) dapat menyimpanan data sampai 700 MB,
hanya dapat menyimpan sekali tidak dapat diulangi. Sedangkan CD-RW
(rewriteable) dapat membaca dan menulis data beberapa kali. DVD-R
dan DVD-RW adalah salah satu media penyimpan optical disk lain yang
mempunyai kemampuan atau kapasitas penyimpan data hingga ukuran
diatas 10 GB dalam 1 piringan.
32
5. USB Flash Disk
USB flash disk (UFD) adalah piranti penyimpanan eksternal yang
berbentuk pena dengan panjang 53-63.5 mm, lebar 17 mm dan tinggi 8
mm dan dicolokkan ke port USB. Kapasitas penyimpanan data
mencapai 8 GB. Dibandingkan disket atau CD, USB flash disk akses
datanya relatif lebih cepat atau hampir sama dengan harddisk.
2.7 Metode Pengembangan Sistem
2.7.1 Model-model Proses Perangkat Lunak
Untuk menyelesaikan masalah yang ada dalam sebuah perancangan
perangkat lunak diperlukan model-model proses atau paradigma rekayasa
perangkat lunak berdasarkan sifat aplikasi dan proyeknya, metode dan alat bantu
yang dipakai, dan kontrol serta penyampaian yang dibutuhkan. Menyebutkan ada
beberapa model dari proses perangkat lunak, di antaranya (Pressman, 2002:35) :
2.7.1.1 Model Sekuensial Linear
Model sekuensial linear mengusulkan sebuah pendekatan kepada
perkembangan perangkat lunak yang sistematik dan sekuensial yang mulai pada
tingkat dan kemajuan sistem pada seluruh analisis, desain, kode pengujian, dan
pemeliharaan (Pressman, 2002:36). Gambar 2.6 menunjukkan sekuensial linear
untuk rekayasa perangkat lunak, yang sering disebut juga dengan “siklus
kehidupan klasik” atau “model air terjun”.
33
Analisis Desain Kode Tes
Pemodelan Sistem
Informasi
Gambar 2.6 Model sekuensial linear
2.7.1.2 Model Prototipe
Protyping paradigma (gambar 2.7) dimulai dengan pengumpulan kebutuhan.
Pengembang dan pelanggan bertemu dan mendefinisikan obyektif keseluruhan
dari perangkat lunak, mendefinisikan segala kebutuhan yang diketahui, dan area
garis besar di mana definisi lebih jauh merupakan keharusan kemudian dilakukan
“perancangan kilat”. Perancangan kilat berfokus pada penyajian dari aspek-aspek
perangkat lunak tersebut yang akan nampak bagi pelanggan/pemakai (contohnya
pendekatan input dan format output). Prototipe tersebut dievaluasi oleh
pelanggan/pemakai dan dipakai untuk menyaring kebutuhan pengembangan
perangkat lunak (Pressman, 2002:40).
Mendengarkan
Pelanggan
Membangun
Memperbaiki
Market
Uji Pelanggan
Mengendalikan
Market
Gambar 2.7 Prototipe paradigma
34
2.7.1.3 Model RAD
RAD (Rapid Application Development) adalah sebuah model proses
perkembangan perangkat lunak sekuensial linear yang menekankan siklus
pengembangan yang sangat pendek. Model RAD ini merupakan sebuah adaptasi
“kecepatan tinggi” dari model sekuensial linear di mana perkembangan cepat
dicapai dengan menggunakan model pendekatan konstruksi berbasis komponen.
Jika kebutuhan dipahami dengan baik, proses RAD memungkinkan tim
pengembang menciptakan “sistem fungsional yang utuh” dalam waktu periode
yang sangat pendek (kira-kira 60 sampai 90 hari). Karena dipakai terutama pada
aplikasi sistem konstruksi (Pressman, 2002:42).
Pendekatan RAD meliputi fase-fase (Kendall & Kendall, 2003:237) :
1. Fase Perencanaan Syarat
Dalam fase ini, pengguna dan penganalisis bertemu untuk
mengidentifikasi tujuan-tujuan aplikasi atau sistem serta untuk
mengidentifikasi syarat-syarat informasi yang ditimbulkan dari tujuan-
tujuan tersebut.
2. Workshop Desain RAD
Fase ini adalah fase untuk merancang dan memperbaiki yang bisa
digambarkan sebagai workshop. Terdiri atas fase perancangan dan fase
konstruksi.
3. Fase Implementasi
Dalam gambar 2.7 ditunjukkan bahwa anda dapat melihat penganalisis
bekerja dengan pengguna secara intens selama workshop untuk merancang
35
aspek-aspek bisnis dan nonteknis dari perusahaan. Segera sesudah aspek-
aspek ini disetujui dan sistem-sistem dibangun dan disaring, sistem-sistem
baru atau bagian dari sistem uji coba dan kemudian diperkenalkan kepada
organisasi.
Model RAD seperti gambar 2.8 berikut (Kendall & Kendall, 2003) :
Menentukan Tujuan dan
Syarat-syarat Informasi
Bekerja dengan
Pengguna untuk Sistem
Perancangan
Membangun Sistem
Memperkenalkan Sistem
Menggunakan Masukkan
dari Pengguna
Fase Pelaksanaan
Fase Konstruksi
Fase Perancangan
Syarat-syarat
Umpan Balik
Pengguna
Fase Perancangan
Gambar 2.8 Model RAD (Rapid Application Development)
2.7.1.4 Model Evolusioner
Menurut Gilb, model evolusioner adalah model iterative. Model itu ditandai
dengan tingkah laku yang memungkinkan perekayasa perangkat lunak
mengembangkan versi perangkat lunak yang lebih lengkap sedikit demi sedikit.
36
Terdiri atas model pertambahan, model spiral, model rakitan komponen dan
model perkembangan konkuren (Pressman, 2002:44).
2.7.1.5 Model Formal
Menurut Dyer, model metode formal mencakup sekumpulan aktifitas yang
membawa kepada spesifikasi matematis perangkat lunak komputer. Model formal
memungkinkan perekayasa perangkat lunak untuk mengkhususkan,
mengembangkan, dan memverifikasi sistem berbasis komputer dengan
menggunakan notasi matematis yang tetap (Pressman, 2002:54).
Pada penulisan skripsi ini penulis menggunakan metode pengembangan
sistem RAD (Rapid Application Development).
2.7.2 Perbandingan Metode Perangkat Lunak
Menurut Hanna, kekurangan pada model sekuensial linear adalah sebagai
berikut (Pressman, 2002:39) :
1. Jarang sekali proyek nyata mengikuti aliran sekuensial yang dianjurkan
oleh model. Meskipun model linear bisa mengakomodasikan iterasi,
model itu melakukannya dengan cara tidak langsung. Sebagai hasilnya,
perubahan-perubahan dapat menyebabkan keraguan pada saat tim
proyek berjalan.
2. Kadang sulit bagi pelanggan untuk menyatakan semua kebutuhannya
secara eksplisit. Model sekuensial linear memerlukan hal ini dan
mengalami kesulitan untuk mengakomodasi ketidakpastian natural yang
ada pada bagian awal beberapa proyek.
37
3. Pelanggan harus bersikap sabar. Sebuah versi kerja dari progam-
program itu tidak akan diperoleh sampai akhir waktu proses dilalui.
Sebuah kesalahan besar, jika tidak terdeteksi sampai program yang
bekerja tersebut dikaji ulang, bisa menjadi petaka.
4. Pengembang sering melakukan penundaan yang tidak perlu. Karena
suatu tim harus mengunggu tim yang lain untuk melengkapi tugas yang
saling memiliki ketergantungan.
Menurut Brooks, kekurangan pada model prototipe adalah sebagai berikut
(Pressman, 2002:41) :
1. Pelanggan melihat apa yang tampak sebagai versi perangkat lunak yang
bekerja tanpa melihat bahwa prototipe itu dijalin bersama-sama tanpa
melihat bahwa di dalam permintaan untuk membuatnya bekerja, kita
belum mencantumkan kualitas perangkat lunak secara keseluruhan atau
kemampuan pemeliharaan untuk jangka waktu yang panjang.
2. Pengembang sering membuat kompromi-kompromi implementasi untuk
membuat prototipe bekerja secara cepat. Sistem operasi atau bahasa
pemogram yang tidak sesuai bisa dipakai secara sederhana karena
mungkin diperoleh dan dikenal. Kurang ideal untuk sebuah sistem.
Menurut Butler, kekurangan model RAD (Rapid Application Development)
adalah sebagai berikut (Pressman, 2002:44) :
1. Bagi proyek yang besar tetapi berskala, RAD memerlukan sumber daya
manusia yang memadai untuk menciptakan jumlah tim RAD yang baik.
38
2. RAD menuntuk pengembang dan pelanggan memiliki komitmen di
dalam aktifitas rapid-fire yang diperlukan untuk melengkapi sebuah
sistem, di dalam kerangka waktu yang sangat diperpendek. Jika
komitmen tersebut tidak ada dari tiap konstituen, proyek RAD akan
gagal.
Kekurangan pada model formal adalah sebagai berikut (Pressman, 2002:54):
1. Pengembangan model formal banyak memakan waktu dan mahal.
2. Karena beberapa pengembangan perangkat lunak perlu mempunyai latar
belakang yang diperlukan untuk mengaplikasikan metode formal maka
diperlukan pelatihan yang ekstensif.
3. Sulit untuk menggunakan model-model sebagai sebuah mekanisme
komunikasi bagi pemakai yang secara teknik belum canggih.
2.8 Algoritma Program
2.8.1 Pseudocode
Pseudo berarti imitasi dan code dihubungkan dengan instruksi yang ditulis
di dalam bahasa komputer. Pseudocode digunakan untuk menjembatani jurang
antara bahasa sehari-hari programmer dengan bahasa komputer. Pseudocode
dapat disebut dengan bahasa Inggris terstruktur (structured English), karena
merupakan kombinasi elemen-elemen dasar dari pemograman terstruktur dengan
menggunakan bahasa Inggris. Psudocode dapat juga ditulis dengan bahasa
Indonesia, sehingga dapat juga disebut dengan structured Indondesia (Hartono,
2000:699).
39
Pseudocode merupakan suatu bahasa yang memungkinkan programmer
untuk berpikir terhadap permasalahan yang harus dipecahkan tanpa harus
memikirkan sintaksis dari bahasa pemograman tertentu. Tidak ada aturan
penulisan sintaksis di dalam pseudocode. Jadi, psudocode digunakan untuk
menggambarkan logika urutan-urutan dari program tanpa memandang bagaimana
bahasa pemogramnya.
Pseudocode banyak yang menyebutnya sebagai algoritma. Sebenarnya yang
disebut algoritma adalah urutan langkah-langkah logis penyelesaian masalah yang
disusun secara sistematis (Munir, 2001:4). Jadi, algoritma tidak saja harus
membentuk pseudocode, tatapi dapat juga diwujudkan dalam bentuk flowchart.
2.8.2 Diagram Alur (Flowchart)
Diagram alur merupakan suatu bagan yang menggambarkan arus logika dari
data yang akan diproses dalam suatu program dari awal sampai akhir (Hartono,
2000:622).
Diagram alur merupakan alat yang berguna bagi programmer untuk
mempersiapkan program yang rumit. Diagram alur dapat menunjukkan secara
jelas arus pengendalian algoritma, yakni bagaimana rangkaian pelaksanaan
kegiatan.
Diagram alur terdiri dari simbol-simbol yang mewakili fungsi-fungsi
langkah-langkah program dan garis alir (flow lines) menunjukkan urutan dari
simbol-simbol yang akan dikerjakan.
Berikut ini adalah simbol-simbol program diagram alur menurut ANSI
(American Nasional Standart Institute).
40
Tabel 2.2 Simbol-simbol diagram alur
SIMBOL NAMA FUNGSI
Terminator
Untuk menunjukkan awal dan akhir dari
program
Persiapan
Untuk memberikan nilai awal pada suatu
variabel atau counter atau inisialisasi
Pengolahan
Untuk pengolahan aritmatika dan
pemindahan data
Keputusan
Untuk mewakili operasi perbandingan
logika
Proses
Terdefinisi
Untuk proses yang detailnya dijelaskan
terpisah, misalnya dalam bentuk sub-
routine
Penghubung
Untuk menunjukkan hubungan arus proses
yang terputus masih dalam halaman yang
sama
Penghubung
Halaman
Lain
Untuk menunjukkan hubungan arus proses
yang terputus tetapi diluar halaman
Penjelasan
Untuk memberikan keterangan-keterangan
guna memperjelas simbol-simbol yang lain
41
Garis Alir Arah aliran program
2.8.3 STD (State Transition Diagram)
Menurut Hoffer, State Transition Diagram merupakan suatu diagram yang
menggambarkan bagaimana state dihubungkan dengan state lain pada satu waktu.
State Transition Diagram menggambarkan suatu state yang mempunyai kondisi
dimana menyebabkan perubahan satu state ke state yang lain (Pressman,
2002:328).
State Transition Diagram pada dasarnya merupakan sebuah diagram yang
terdiri dari state dan transisi atau pemindahan state. Transisi atau perpindahan
state terdiri dari kondisi dan aksi. Transisi diantara kedua keadaan pada umumnya
disebabkan oleh suatu kondisi. Kondisi adalah suatu kejadian yang dilakukan oleh
sistem. Sedangkan aksi adalah tindakan yang dilakukan oleh sistem apabila terjadi
perubahan state atau perubahan reaksi dari sistem (Pressman, 2002:328). Seperti
pada gambar 2.9 berikut ini :
State 1
State 1
Aksi
Gambar 2.9 Contoh perubahan state
42
Adapun komponen atau simbol yang digunakan dalam diagram adalah
sebagai berikut :
1. Modul
Menggunakan simbol lingkaran kecil (gambar 2.10) yang mewakili modul
yang akan dipanggil apabila terjadi suatu tindakan.
Gambar 2.10 Notasi Modul
2. Tampilan kondisi (state)
Merupakan layer yang ditampilkan menurut keadaan atau atribut, untuk
memenuhi suatu tindakan pada waktu tertentu yang mewakili suatu bentuk
keadaan atau kondisi tertentu, disimbolkan dengan gambar kotak (gambar
2.11).
Gambar 2.11 Notasi Tampilan
3. Tindakan (state transition)
Menggunakan simbol anak panah (gambar 2.12) disertai keterangan tindakan
yang dilakukan.
Gambar 2.12 Notasi Tindakan
43
2.9 Framework .NET
2.9.1 Pengertian Microsoft .NET Framework
Microsoft .NET framework (dibaca microsoft dot net framework) adalah
sebuah komponen yang dapat ditambahkan ke sistem operasi Microsoft Windows
atau telah terintegrasi ke dalam Windows (mulai dari Windows Server 2003 dan
versi-versi Windows terbaru). Kerangka kerja ini menyediakan sejumlah besar
solusi-solusi program untuk memenuhi kebutuhan-kebutuhan umum suatu
program baru, dan mengatur eksekusi program-program yang ditulis secara
khusus untuk framework ini. .NET framework adalah kunci penawaran utama dari
Microsoft, dan dimaksudkan untuk digunakan oleh sebagian besar aplikasi-
aplikasi baru yang dibuat untuk platform Windows (http://id.wikipedia.org/).
Framework .NET di disain untuk dapat memenuhi beberapa tujuan berikut
ini (Kurniawan, 2004:14):
1. Untuk menyediakan lingkungan kerja yang konsisten bagi bahasa
pemograman yang berorientasi objek (object oriented programming)
baik kode itu disimpan dan dieksekusi secara lokal, atau dieksekusi
secara lokal tetapi didistribusikan melalui Internet atau dieksekusi secara
remote.
2. Untuk menyediakan lingkungan kerja di dalam mengeksekusi kode yang
dapat meminimalisasi proses software deployment dan menghindari
konflik penggunaan software yang dibuat.
44
3. Untuk menyediakan lingkungan kerja yang aman dalam hal
pengeksekusian kode, termasuk kode yang dibuat oleh pihak ketiga
(third party).
4. Untuk menyediakan lingkungan kerja yang dapat mengurangi masalah
pada persoalan performa dari kode atau dari lingkungan interpreter-nya.
5. Membuat para developer lebih mudah mengembangkan berbagai macam
jenis aplikasi yang bervariasi, seperti aplikasi berbasis windows dan
aplikasi berbasis web.
6. Membangun semua komunikasi yang ada di dalam standar industri
untuk memastikan bahwa kode aplikasi berbasis framework .NET dapat
berintegrasi dengan berbagai macam kode aplikasi lain.
Sebagai salah satu sarana untuk dapat memenuhi tujuan yang telah
dipaparkan, maka dibuatlah berbagai macam bahasa pemograman yang dapat
digunakan dan dapat berjalan di atas platform framework .NET seperti bahasa C#,
VB.NET, C++, J#, Perl.NET dan lain-lain. Masing-masing bahasa tersebut
mempunyai kelebihan dan kekurangannya masing-masing, namun yang pasti,
apapun bahasa pemograman yang digunakan, semua dapat saling berkomunikasi
dan saling compatible satu dengan yang lainnya dengan bantuan framework .NET.
2.9.2 Arsitektur Framework .NET
Framework .NET terdiri dari dua komponen utama, yaitu CLR (Common
Language Runtime) dan .NET Framework Class Library atau kadang juga sering
disebut dengan BCL (Base Class Library).
45
VB.NETManaged
C++C# PERL.NET
Other .NET
Language
Common Language Specification
Web Services
Web FormsWindows Forms
Data dan XML
Base Class Library
Common Language Runtime
Visual
Studio
.NET
Gambar 2.13 Arsitektur framework .NET
2.9.2.1 CLR (Common Language Runtime)
CLR merupakan pondasi utama dari framework .NET. CLR merupakan
komponen yang bertanggung jawab terhadap berbagai macam hal, seperti
bertanggung jawab untuk melakukan manajemen memori, melakukan eksekusi
kode, melakukan verifikasi terhadap keamanan kode dan berbagai layanan sistem
lainnya. Dengan adanya fungsi CLR ini, maka aplikasi berbasis .NET bisa juga
disebut dengan managed code, sedangkan aplikasi di luar itu bisa disebut dengan
un-managed code.
Berikut ini beberapa hal yang disediakan oleh CLR bagi para developer
(Kurniawan, 2004:15) :
1. Dapat lebih menyederhanakan proses pengembangan aplikasi.
2. Memungkinkan adanya variasi dan integrasi dari berbagai bahasa
pemograman yang ada di lingkungan framework .NET.
3. Keamanan dengan menggunakan indentifying pada kode aplikasi.
46
4. Bersifat assembly pada saat proses deployment/kompilasi.
5. Melakukan versioning sebuah komponen yang bisa di daur ulang.
6. Memungkinkan penggunaan kembali kode, dengan adanya sifat
inheritance.
7. Melakukan pengaturan/manajemen tentang lifetime sebuah objek.
8. Melakukan penganalisaan objek secara otomatis
CLR melakukan kompilasi kode-kode aplikasi menjadi bahasa assembly
MSIL (Microsoft Intermediate Language). Proses kompilasi ini sendiri dilakukan
oleh komponen yang bernama JIT (Just in Time). JIT hanya akan mengkopilasi
metode-metode yang memang digunakan dalam aplikasi, dan hasil kompilasi ini
sendiri di simpan di dalam mesin dan akan dikompilasi kembali jika memang ada
perubahan pada kode aplikasi.
2.9.2.2 BCL (Base Class Library)
.NET Framework Class Library atau sering juga disebut BCL adalah koleksi
dari reusable types yang sangat terintegrasi secara melekat dengan CLR. Kelas
library bersifat berorientasi terhadap objek yang akan menyediakan types dari
fungsi-fungsi managed code. Hal ini juga dapat mengurangi waktu yang
diperlukan pada saat eksekusi. Dengan sifat tersebut, maka komponen pihak
ketiga (third party) akan dengan mudah diaplikasikan ke dalam aplikasi yang
dibuat.
Dengan adanya BCL ini, maka kita bisa menggunakan framework .NET
untuk membuat berbagai macam aplikasi, seperti (Kurniawan, 2004:15) :
1. Aplikasi console
47
2. Aplikasi berbasis windows (Windows Form)
3. Aplikasi berbasis ASP.NET (berbasis web)
4. Aplikasi Web Services XML
5. Aplikasi berbasis Windows Services
Jika kita membuat sekumpulan kelas untuk membuat aplikasi berbasis
windows (Windows Form), maka kelas-kelas itu bisa kita gunakan untuk aplikasi
lain, seperti aplikasi berbasis web.
2.9.3 Keuntungan Framework .NET
Berikut ini adalah beberapa keuntungan dari penggunaan framework .NET
(Kurniawan, 2004:16) :
1. Mudah
Kemudahan di sini lebih ke arah pada kemudahan developer untuk
membuat aplikasi yang dijalankan pada lingkungan framework .NET.
Beberapa yang merepotkan developer pada saat membuat aplikasi telah
di hilangkan atau diambil alih kemampuannya oleh framework .NET,
misalnya masalah lifetime sebuah objek yang bisanya luput dari
perhatian developer pada saat proses pembuatan aplikasi. Masalah ini
telah ditangani dan diatur secara otomatis oleh framework .NET melalui
komponen yang bernama gerbage collector yang bertanggung jawab
untuk mencari dan membuat objek yang sudah tidak terpakai secara
otomatis.
48
2. Efisien
Kemudahan pada saat proses pembuatan aplikasi, akan berimplikasi
terhadap efisiensi dari suatu proses produktifitas, baik efisien dalam hal
waktu pembuatan aplikasi atau juga efisien dalam hal lain, seperti biaya.
3. Konsisten
Kemudahan-kemudahan pada saat pembuatan aplikasi, juga bisa
berimplikasi terhadap kosistensi pada aplikasi yang kita buat. Misalnya
dengan adanya BCL, maka kita bisa menggunakan objek atau kelas
yang dibuat untuk aplikasi berbasis windows pada aplikasi berbasis web.
Dengan adanya kode yang bisa diintegrasikan ke dalam berbagai macam
aplikasi ini, maka kosistensi kode-kode aplikasi dapat terjaga.
4. Produktifitas
Semua kemudahan-kemudahan di atas, pada akhirnya akan membuat
produktifitas menjadi lebih baik. Produktifitas naik, terutama
produktifitas para developer, akan berdampak pada meningkatnya
produktifitas suatu perusahaan.
2.10 Mono Framework
Mono adalah sebuah proyek yang dipimpin oleh Novell (dulunya oleh
Ximian) untuk membuat suatu ECMA (European Computer Manufactur
Association) compliant standar sekumpulan peralatan-peralatan kompatibel .NET,
meliputi salah satunya C# compiler dan suatu CLR. Mono dapat berjalan pada
49
sistem operasi Linux, FreeBSD, UNIX Mac OS X, Solaris dan Microsoft
Windows (http://id.wikipedia.org).
Mono merupakan dual licensed oleh Novell, serupa dengan produk-produk
lain seperti Qt dan Mozilla Application Suite. Compiler C# Mono dan
peralatannya dirilis di bawah GPL (General Public License), pustaka-pustaka
runtime di bawah LGPL (GNU Lasser General Public License) dan pustaka-
pustaka kelas di bawah MIT License.
2.11 Sekilas Tentang Visual C#
2.11.1 Pengertian C#
C# (dibaca “See-Sharp”) merupakan bahasa pemograman moderen yang
berorientasi objek. Secara sintaks C# mirip dengan bahasa-bahasa pemograman
keluarga C seperti C, C++, dan Java. C# menggabungkan produktifitas dan
kemudahan yang ada di pemograman Visual Basic dengan kemampuan dan
fleksibilitas yang ada di pemograman C++, dan menambahkan hal-hal baru yang
tidak ada di bahasa pemograman Java. Perancang utamanya adalah Anders
Hejlsberg dari Microsoft, yang dulunya membuat bahasa pemograman Turbo
Pascal dan berperan dalam pengembangan bahasa pemograman Delphi dan
Borland Delphi.
Bahasa C# telah diserahkan oleh Microsoft ke badan standar intenasional
ECMA (European Computer Manufacture Assosiation). Proses standarisasinya
selesai pada Desember 2001 dengan nama standarnya ECMA-334. Dengan
50
standar tersebut, siapapun dapat dengan mudah dan bebas membuat implementasi
bahasa C#.
2.11.2 Alasan Menggunakan Bahasa C#
Ada beberapa alasan menggunakan bahasa C#, yaitu (Kurniawan, 2004:17):
1. Sederhana (simple)
Bahasa C# bersifat sederhana, karena bahasa C# didasarkan kepada
bahasa C dan C++. Bahasa C# menghilangkan beberapa hal yang
bersifat kompleks yang terdapat dalam beberapa macam bahasa
pemograman Java dan C++, temasuk diantaranya mengilangkan macro,
templates, multiple inheritance, dan virtual base classes. Hal-hal
tersebut juga dapat menyebabkan kebingungan pada saat
menggunakannya, berpotensial dapat menjadi masalah bagi para
programmer C++.
2. Moderen
Apa yang membuat bahasa C# menjadi suatu bahasa pemograman yang
moderen ?. Jawabannya adalah adanya beberapa fitur seperti exception
handling, garbage collection, extensible data types, dan code security
(keamanan kode/bahasa pemograman). Dengan fitur-fitur tersebut,
menjadikan bahasa C# sebagai bahasa pemograman yang modern.
3. Object-Oriented Language
Kunci dari bahasa pemograman yang bersifat object-oriented adalah
encapsulation, inheritance, dan polymorphism. Sifat-sifat tersebut
51
dimiliki oleh bahasa C# sehingga bahasa C# merupakan bahasa yang
bersifat Object-Oriented.
4. Powerfull dan fleksibel
C# bisa digunakan untuk membuat berbagai macam aplikasi, seperti
sebuah aplikasi pengolah kata, grapik, spreadsheets, atau bahkan
membuat compiler untuk sebuah bahasa pemograman.
5. Efisien
Bahasa C# adalah bahasa pemograman menggunakan jumlah kata-kata
yang tidak terlalu banyak. C# hanya berisi kata-kata yang bisa disebut
dengan keywords. Keywords ini digunakan untuk menjelaskan berbagai
macam informasi.
6. Modular
Kode C# ditulis dengan pembagian masing classes yang terdiri dari
beberapa routines yang disebut sebagai member methods. Classes dan
metode-metode ini dapat digunakan kembali oleh program dan aplikasi
lain. Hanya dengan memberikan informasi yang dibutuhkan oleh class
dan metode yang dimaksud, maka kita akan dapat membuat suatu kode
yang dapat digunakan oleh satu atau beberapa aplikasi dan program
(reusable code).
7. C# akan menjadi popular
Dengan dukungan penuh dari Microsoft yang akan mengeluarkan
produk-produk utamanya dengan dukungan framework .NET, maka
52
masa depan bahasa C# sebagai salah satu bahasa pemograman yang ada
di dalam lingkungan framework .NET akan lebih baik.
2.11.3 Mengenal Integrated Development Environment Visual Studio 2005
Gambar 2.14 Splash Screen Visual Studio 2005
53
Tampilan lingkungan Visual Studio 2005 seperti Gambar 2.15 berikut ini :
Gambar 2.15 Tampilan Lingkungan Visual Studio 2005
54
BAB III
METODOLOGI PENELITIAN
3 METODOLOGI PENELITIAN
Dalam penelitian ini, metode penelitian yang penulis lakukan terbagi
menjadi dua metode yaitu metode pengumpulan data dan metode pengembangan
sistem.
3.1 Metode Pengumpulan Data
Tahap ini dilakukan dilakukan sebelum tahap pengembangan sistem. Tahap
ini meliputi studi pustaka.
3.1.1 Studi Pustaka
Metode studi pustaka dilakukan dengan mengumpulkan data dan informasi
yang dijadikan sebagai acuan untuk analisi dan penerapan algoritma string
matching pada aplikasi pencarian berkas di komputer. Referensi tersebut berasal
dari buku-buku pegangan maupun publikasi hasil penelitian yang berhubungan
dengan algoritma string matching, metode pengembangan sistem metode RAD,
serta bahasa pemograman visual C# sebagai tools pengembang aplikasi.
3.2 Metode Pengembangan Sistem
Pengembangan sistem yang penulis lakukan menggunakan pengembangan
model RAD. Empat tahap siklus pengembangan model RAD, yaitu fase
perancangan syarat, fase perancangan, fase konstruksi dan fase implementasi
(Kendall & Kendall, 2003:327). Model RAD penulis gunakan untuk melakukan
pendekatan berorientasi objek terhadap pengembangan sistem yang mencakup
55
suatu metode pengembangan perangkat-perangkat lunak. Tujuan yang lain adalah
mempersingkat waktu pengerjaan aplikasi serta proses yang dihasilkan didapatkan
secara cepat dan tepat. Syarat-syarat menggunakan RAD adalah pihak perekayasa
perangkat lunak telah mengetahui dengan jelas kebutuhan user (pengguna) dengan
tepat, mengetahui proses-proses apa saja yang ada dalam perangkat lunak yang
dibuat, input/output yang dihasilkan.
Model RAD seperti pada gambar 3.1 berikut ini (Kendall & Kendall, 2003:
237):
Menentukan Tujuan dan
Syarat-syarat Informasi
Bekerja dengan
Pengguna untuk Sistem
Perancangan
Membangun Sistem
Memperkenalkan Sistem
Menggunakan Masukkan
dari Pengguna
Fase Pelaksanaan
Fase Konstruksi
Fase Perancangan
Syarat-syarat
Umpan Balik
Pengguna
Fase Perancangan
Gambar 3.1 Siklus Pengembangan Sistem Model RAD
56
3.2.1 Fase Perencanaan Syarat-syarat
Pada tahap ini dilakukan pengidentifikasian tujuan-tujuan aplikasi atau
sistem serta untuk mengidentifikasi syarat-syarat informasi yang ditimbulkan dari
tujuan-tujuan tersebut.
3.2.2 Fase Perancangan
Pada tahap ini akan dilakukan perancangan proses yaitu perancangan
proses-proses yang akan terjadi di dalam sistem, perancangan antarmuka yaitu
perancangan antarmuka masukan dan antarmuka keluaran.
3.2.3 Fase Konstruksi
Pada tahap ini dilakukan pengkodean terhadap rancangan-rancangan yang
telah didefinisikan
3.2.4 Fase Implementasi
Pada tahap ini dilakukan pengujian masing-masing modul (unit) program
apakah sesuai dengan tugasnya kemudian dilakukan uji coba terhadap integrasi
keseluruhan unit program untuk mengetahui apakah sistem yang telah dibuat
sudah memenuhi kriteria yang diinginkan.
3.3 Alasan penulis menggunakan RAD
Berikut ini adalah beberapa alasan penulis menggunakan RAD dalam
Analisis dan Penerapan Algoritma String Matching pada Aplikasi Pencarian
Berkas Di Komputer :
1. Melihat dari aplikasi yang akan dikembangkan oleh penulis, merupakan
aplikasi yang sederhana dan tidak memerlukan waktu yang lama.
57
Metode RAD adalah metode yang diperuntukkan untuk jangka pendek.
Sesuai dengan aplikasi yang akan dikembangkan.
2. Suatu kebutuhan telah dipahami dengan baik menyangkut pokok
permasalahan akan didapat suatu sistem fungsional yang utuh dalam
jangka pendek pada metode RAD.
3. Pengembangan aplikasi pencarian berkas di komputer dalam
implementasinya tidak memiliki fase pemeliharaan. Karena merupakan
aplikasi sederhana untuk alasan ini penulis tidak menggunakan metode
sekuensial linear.
4. Pada pengembangan motode prototipe bisanya digunakan untuk
membuat sistem yang pertama. Model ini bisanya digunakan sebagai
awal dari perancangan (Pressman, 2002:41).
5. Metode evolusioner menggunakan fase yang panjang dalam
penyelesaian suatu masalah. Fase ini disebutkan sebagai fase
pertambahan. Aplikasi pencarian berkas di komputer merupakan
aplikasi yang sederhana dan tidak memerlukan tahapan yang panjang.
6. Pengembangan metode formal menggunakan sekumpulan aktifitas
kepada spesifikasi matematis pada perangkat lunak komputer. Sehingga
banyak memakan waktu menurut Dyer (dalam Pressman, 2002:54).
Mengingat keterbatasan waktu yang dimiliki oleh penulis. Maka penulis
tidak menggunakan metode formal.
7. Selain itu motode formal memerlukan model-model komunikasi yang
cukup sulit untuk digunakan, mengingat keterbatasan penulis.
58
BAB IV
PERANCANGAN DAN IMPLEMENTASI
4 PERANCANGAN DAN IMPLEMENTASI
Perancangan dan pengembangan aplikasi pencarian berkas di komputer,
penulis menggunakan metode RAD. Tahapan-tahapan RAD terdiri dari fase
perencanaan syarat-syarat, fase perancangan, fase konstruksi dan fase pelaksanaan
(Kendall & Kendall, 2003:327).
4.1 Fase Perencanaan Syarat-Syarat
4.1.1 Mendefiniskan Masalah
Tahap mendefinisikan masalah adalah tahap untuk menentukan masalah apa
yang harus diselesaikan dengan menggunakan aplikasi yang dibuat (Kendall &
Kendall, 2003:328).
Pengembangan dan perancangan aplikasi pencarian berkas di komputer ini
ditujukan untuk menerapkan algoritma string matching dengan objek berkas yang
berada di komputer, serta mengetahui perbandingan kinerja dari ketiga algoritma
string matching, yaitu algoritma brute-force, algoritma knuth-morris-pratt dan
algoritma boyer-moore. Aplikasi ini juga berguna bagi pengguna untuk mencari
berkas yang berada di komputer.
4.1.2 Analisis Algoritma String Matching
Sebelum memasuki bahasan lebih lanjut penulis akan melakukan uji coba
terhadap algoritma brute force, algoritma knuth-morris-pratt dan algoritma boyer-
moore secara manual. Pada uji coba ini penulis akan memberikan teks dan pattern
59
yang sama untuk ketiga algoritma tersebut, untuk teks dan pattern-nya sebagai
berikut :
Teks (T) : GCATCGCAGAGAGTATACAGTACG
Pattern (P) : GCAGAGAG
4.1.2.1 Analisis Algoritma Brute Force
Dari uji coba tersebut, diperoleh keterangan nilai dasar :
T = Teks : GCATCGCAGAGAGTATACAGTACG
P = Pattern : GCAGAGAG
m = Panjang dari teks (T) : 24
n = Panjang dari pattern (P) : 8
Sebelum penulis melakukan proses pencocokkan string dengan
menggunakan algoritma brute force, ada baiknya penulis ulang kembali tentang
pseudocode algoritma brute force.
1. function BruteForceSearch( 2. input n : integer, { panjang pattern }
3. input m : integer, { panjang teks }
4. input P : string, { string pattern }
5. input T : string, { string teks }
6. ) boolean
7.
8. Deklarasi
9. i : integer { pointer dari teks }
10. j : integer { ponter dari pattern }
11. ketemu : boolean { menampung nilai ketemu }
12.
13. Algoritma
14. i := 0
15. ketemu := false
16. while ( i <= m – n) do
17. j := 0
18. while (j < n) and (T[i + j] = P[j]) do
19. j := j + 1
20. endwhile
21. if j >= n then
22. ketemu := true
23. endif
24. i := i + 1
25. endwhile
26. return ketemu
60
Kita akan melaksanakan proses pencocokkan string dengan menggunakan
algoritma brute force, langkah – langkahnya sebagai berikut :
1. Baris ke-1 merupakan pemanggilan fungsi BruteForceSearch
2. Baris ke-2 merupakan sebuah masukan dari panjang pattern (n), diketahui
n=8
3. Baris ke-3 merupakan sebuah masukan dari panjang teks (m), diketahui m=24
4. Baris ke-4 merupakan sebuah masukan dari pattern (P), diketahui
P=GCAGAGAG. Nilai dari P ini yang akan di cari di sebuah teks (T).
5. Baris ke-5 merupakan sebuah masukan dari teks (T), diketahui
T=GCATCGCAGAGAGTATACAGTACG
6. Baris ke-6 menandakan bahwa fungsi ini akan menghasilkan nilai boolean,
true atau false. Jika true berarti proses pencocokkan string ketemu, dan jika
false proses pencocokkan string tidak ketemu
7. Baris ke-8 merupakan sebuah komentar yang berisi Deklarasi
8. Baris ke-9, deklarasikan pointer teks (i) dengan tipedata integer
9. Baris ke-10, deklarasikan pointer pattern (j) dengan tipedata integer
10. Baris ke-11, deklarasikan ketemu dengan tipedata boolean
11. Baris ke-13 merupakan sebuah komentar yang berisi Algoritma yang
menandakan akan dimulainya algoritma ini
12. Baris ke-14, inisialisasikan nilai i=0
13. Baris ke-15, inisialisasikan nilai ketemu=false
14. Baris ke-16, merupakan sebuah kondisi while-do, proses pengulangan while-
do akan berakhir jika kondisi dalam while-do tidak terpenuhi lagi. Nilai awal
pengulangan while(i <= m–n ) adalah while(0<=24–8) atau while(0<=16)
1) Posisi i=0
a. Baris ke-17, inisialisasikan nilai j=0
b. Baris ke-18, periksa kondisi while(j<n and T[i+j]=P[j])
a) while(0<8 and „G‟=‟G‟) hasil kondisi true. Baris ke-19, j=j+1 atau
j=0+1 atau j=1
61
b) while(1<8 and „C‟=‟C‟) hasil kondisi true. Baris ke-19, j=j+1 atau
j=1+1 atau j=2
c) while(2<8 and „A‟=‟A‟) hasil kondisi true. Baris ke-19, j=j+1 atau
j=2+1 atau j=3
d) while(3<8 and „T‟=‟G‟) hasil kondisi false, keluar dari while, nilai
j=3
c. Baris ke-21, periksa kondisi if(j>=n) atau if(3>=8) hasil kondisi false
d. Baris ke-24, tambahkan nilai i=i+1 atau i=0+1, nilai i=1
2) Posisi i=1
a. Baris ke-17, inisialisasikan nilai j=0
b. Baris ke-18, periksa kondisi while(j<n and T[i+j]=P[j])
a) while(0<8 and „C‟=‟G‟) hasil kondisi false, keluar dari while, nilai
j=0
c. Baris ke-21, periksa kondisi if(j>=n) atau if(0>=8) hasil kondisi false
d. Baris ke-24, tambahkan nilai i=i+1 atau i=1+1, nilai i=2
3) Posisi i=2
a. Baris ke-17, inisialisasikan nilai j=0
b. Baris ke-18, periksa kondisi while(j<n and T[i+j]=P[j])
a) while(0<8 and „A‟=‟G‟) hasil kondisi false, keluar dari while, nilai
j=0
c. Baris ke-21, periksa kondisi if(j>=n) atau if(0>=8) hasil kondisi false
d. Baris ke-24, tambahkan nilai i=i+1 atau i=2+1, nilai i=3
4) Posisi i=3
a. Baris ke-17, inisialisasikan nilai j=0
b. Baris ke-18, periksa kondisi while(j<n and T[i+j]=P[j])
a) while(0<8 and „T‟=‟G‟) hasil kondisi false, keluar dari while, nilai
j=0
c. Baris ke-21, periksa kondisi if(j>=n) atau if(0>=8) hasil kondisi false
d. Baris ke-24, tambahkan nilai i=i+1 atau i=3+1, nilai i=4
5) Posisi i=4
a. Baris ke-17, inisialisasikan nilai j=0
62
b. Baris ke-18, periksa kondisi while(j<n and T[i+j]=P[j])
a) while(0<8 and „C‟=‟G‟) hasil kondisi false, keluar dari while, nilai
j=0
c. Baris ke-21, periksa kondisi if(j>=n) atau if(0>=8) hasil kondisi false
d. Baris ke-24, tambahkan nilai i=i+1 atau i=4+1, nilai i=5
6) Posisi i=5
a. Baris ke-17, inisialisasikan nilai j=0
b. Baris ke-18, periksa kondisi while(j<n and T[i+j]=P[j])
a) while(0<8 and „G‟=‟G‟) hasil kondisi true. Baris ke-19, j=j+1 atau
j=0+1 atau j=1
b) while(1<8 and „C‟=‟C‟) hasil kondisi true. Baris ke-19, j=j+1 atau
j=1+1 atau j=2
c) while(2<8 and „A‟=‟A‟) hasil kondisi true. Baris ke-19, j=j+1 atau
j=2+1 atau j=3
d) while(3<8 and „G‟=‟G‟) hasil kondisi true. Baris ke-19, j=j+1 atau
j=3+1 atau j=4
e) while(4<8 and „A‟=‟A‟) hasil kondisi true. Baris ke-19, j=j+1 atau
j=4+1 atau j=5
f) while(5<8 and „G‟=‟G‟) hasil kondisi true. Baris ke-19, j=j+1 atau
j=5+1 atau j=6
g) while(6<8 and „A‟=‟A‟) hasil kondisi true. Baris ke-19, j=j+1 atau
j=6+1 atau j=7
h) while(7<8 and „G‟=‟G‟) hasil kondisi true. Baris ke-19, j=j+1 atau
j=7+1 atau j=8
i) while(8<8 and „T‟=‟0‟) hasil kondisi false, keluar dari while-do,
nilai j=8
c. Baris ke-21, periksa kondisi if(j>=n) atau if(8>=8) hasil kondisi true
d. Baris ke-24, tambahkan nilai i=i+1 atau i=5+1, nilai i=6
7) Posisi i=6
a. Baris ke-17, inisialisasikan nilai j=0
b. Baris ke-18, periksa kondisi while(j<n and T[i+j]=P[j])
63
a) while(0<8 and „C‟=‟G‟) hasil kondisi false, keluar dari while, nilai
j=0
c. Baris ke-21, periksa kondisi if(j>=n) atau if(0>=8) hasil kondisi false
d. Baris ke-24, tambahkan nilai i=i+1 atau i=6+1, nilai i=7
8) Posisi i=7
a. Baris ke-17, inisialisasikan nilai j=0
b. Baris ke-18, periksa kondisi while(j<n and T[i+j]=P[j])
a) while(0<8 and „A‟=‟G‟) hasil kondisi false, keluar dari while, nilai
j=0
c. Baris ke-21, periksa kondisi if(j>=n) atau if(0>=8) hasil kondisi false
d. Baris ke-24, tambahkan nilai i=i+1 atau i=7+1, nilai i=8
9) Posisi i=8
a. Baris ke-17, inisialisasikan nilai j=0
b. Baris ke-18, periksa kondisi while(j<n and T[i+j]=P[j])
a) while(0<8 and „G‟=‟G‟) hasil kondisi true. Baris ke-19, j=j+1 atau
j=0+1 atau j=1
b) while(0<8 and „A‟=‟C‟) hasil kondisi false, keluar dari while, nilai
j=1
c. Baris ke-21, periksa kondisi if(j>=n) atau if(1>=8) hasil kondisi false
d. Baris ke-24, tambahkan nilai i=i+1 atau i=8+1, nilai i=9
10) Posisi i=9
a. Baris ke-17, inisialisasikan nilai j=0
b. Baris ke-18, periksa kondisi while(j<n and T[i+j]=P[j])
a) while(0<8 and „A‟=‟G‟) hasil kondisi false, keluar dari while, nilai
j=0
c. Baris ke-21, periksa kondisi if(j>=n) atau if(0>=8) hasil kondisi false
d. Baris ke-24, tambahkan nilai i=i+1 atau i=9+1, nilai i=10
11) Posisi i=10
a. Baris ke-17, inisialisasikan nilai j=0
b. Baris ke-18, periksa kondisi while(j<n and T[i+j]=P[j])
64
a) while(0<8 and „G‟=‟G‟) hasil kondisi true. Baris ke-19, j=j+1 atau
j=0+1 atau j=1
b) while(0<8 and „A‟=‟C‟) hasil kondisi false, keluar dari while, nilai
j=1
c. Baris ke-21, periksa kondisi if(j>=n) atau if(1>=8) hasil kondisi false
d. Baris ke-24, tambahkan nilai i=i+1 atau i=10+1, nilai i=11
12) Posisi i=11
a. Baris ke-17, inisialisasikan nilai j=0
b. Baris ke-18, periksa kondisi while(j<n and T[i+j]=P[j])
a) while(0<8 and „A‟=‟G‟) hasil kondisi false, keluar dari while, nilai
j=0
c. Baris ke-21, periksa kondisi if(j>=n) atau if(0>=8) hasil kondisi false
d. Baris ke-24, tambahkan nilai i=i+1 atau i=11+1, nilai i=12
13) Posisi i=12
a. Baris ke-17, inisialisasikan nilai j=0
b. Baris ke-18, periksa kondisi while(j<n and T[i+j]=P[j])
a) while(0<8 and „G‟=‟G‟) hasil kondisi true. Baris ke-19, j=j+1 atau
j=0+1 atau j=1
b) while(1<8 and „T‟=‟C‟) hasil kondisi false, keluar dari while, nilai
j=0
c. Baris ke-21, periksa kondisi if(j>=n) atau if(1>=8) hasil kondisi false
d. Baris ke-24, tambahkan nilai i=i+1 atau i=12+1, nilai i=13
14) Posisi i=13
a. Baris ke-17, inisialisasikan nilai j=0
b. Baris ke-18, periksa kondisi while(j<n and T[i+j]=P[j])
a) while(0<8 and „T‟=‟G‟) hasil kondisi false, keluar dari while, nilai
j=0
c. Baris ke-21, periksa kondisi if(j>=n) atau if(0>=8) hasil kondisi false
d. Baris ke-24, tambahkan nilai i=i+1 atau i=13+1, nilai i=14
15) Posisi i=14
a. Baris ke-17, inisialisasikan nilai j=0
65
b. Baris ke-18, periksa kondisi while(j<n and T[i+j]=P[j])
a) while(0<8 and „A‟=‟G‟) hasil kondisi false, keluar dari while, nilai
j=0
c. Baris ke-21, periksa kondisi if(j>=n) atau if(0>=8) hasil kondisi false
d. Baris ke-24, tambahkan nilai i=i+1 atau i=14+1, nilai i=15
16) Posisi i=15
a. Baris ke-17, inisialisasikan nilai j=0
b. Baris ke-18, periksa kondisi while(j<n and T[i+j]=P[j])
a) while(0<8 and „T‟=‟G‟) hasil kondisi false, keluar dari while, nilai
j=0
c. Baris ke-21, periksa kondisi if(j>=n) atau if(0>=8) hasil kondisi false
d. Baris ke-24, tambahkan nilai i=i+1 atau i=15+1, nilai i=16
17) Posisi i=16
a. Baris ke-17, inisialisasikan nilai j=0
b. Baris ke-18, periksa kondisi while(j<n and T[i+j]=P[j])
a) while(0<8 and „A‟=‟G‟) hasil kondisi false, keluar dari while, nilai
j=0
c. Baris ke-21, periksa kondisi if(j>=n) atau if(0>=8) hasil kondisi false
d. Baris ke-24, tambahkan nilai i=i+1 atau i=16+1, nilai i=17
18) Posisi i=17
Keluar dari while-do, karena tidak sesuai dengan kondisi while(i<=16)
15. Baris ke-26, hasil dari pencocokan string dimana nilai ketemu=true pada
percobaan ke-6) posisi i=5
Untuk kasus terbaik (best case) komplesitas waktunya O(n) dan untuk kasus
terburuk (worst case) kompleksitas waktunya O(m.n). Kasus terbaik terjadi bila
karakter pertama pattern P tidak pernah sama dengan karakter teks T yang
dicocokkan. Kasus terburuknya adalah jika sukses dalam pencarian string kecuali
pada karaktek terakhir.
66
Algoritma brute force sangat power full, namun akan memakan waktu
proses dan tidak efektif bila harus mencari string dalam teks yang sangat panjang.
4.1.2.2 Analisis Algoritma Knuth-Morris-Pratt
Dari uji coba tersebut, diperoleh keterangan nilai dasar :
T = Teks : GCATCGCAGAGAGTATACAGTACG
P = Pattern : GCAGAGAG
m = Panjang dari teks (T) : 24
n = Panjang dari pattern (P) : 8
Berbeda dengan algoritma brute force, algoritma knuth-morris-pratt
menyimpan informasi untuk melakukan pergeseran berdasarkan tabel kmpNext
yang didapat dari fungsi pinggiran.
Sebelum melakukan proses pencocokkan string, algoritma knuth-morris-
pratt akan melakukan pre-processing terhadap fungsi pinggiran untuk
mendapatkan nilai kmpNext. Sebelum melakukan pre-processing terhadap fungsi
pinggiran, ada baiknya penulis ulang kembali tentang psudocode fungsi pinggiran.
1. procedure HitungPinggiran( 2. input n : integer, { panjang pattern }
3. input P : string, { string pattern }
4. output kmpNext : array [1..n] of integer { tabel
kmpNext }
5. )
6.
7. Deklarasi
8. i : integer
9. j : integer
10.
11. Algoritma
12. i := 0
13. j := -1
14. kmpNext[0] := -1
15. while(i < n - 1)
16. while ((j >= 0) and (P[i] ≠ P[j]))
17. j := kmpNext[j]
18. endwhile
19. i := i + 1
20. j := j + 1
21. if(P[i] = P[j])
22. kmpNext[i] := kmpNext[j]
23. else
24. kmpNext[i] := j
67
25. endif
26. endwhile
Kita akan medapatkan nilai tabel kmpNext dengan menjalankan fungsi
pinggiran, langkah-langkahnya sebagai berikut :
1. Baris ke-1 merupakan pemanggilan prosedur HitungPinggiran
2. Baris ke-2 merupakan sebuah masukan dari panjang pattern (n), diketahui
n=8
3. Baris ke-3 merupakan sebuah masukan dari pattern (P), diketahui
P=GCAGAGAG
4. Baris ke-4 merupakan hasil keluaran dari prosedur HitungPinggiran yang
disimpan pada kmpNext dengan tipedata array interger lebar array
berdasarkan panjang pattern (n)
5. Baris ke-7 merupakan sebuah komentar yang berisi Deklarasi
6. Baris ke-8, dideklarasikan pointer untuk kmpNext (i) dengan tipedata integer
7. Baris ke-9, dideklarasikan pointer pattern (j) dengan tipedata integer
8. Baris ke-11 merupakan sebuah komentar yang berisi Algortima yang
menandakan akan dimulainya prosedur ini
9. Baris ke-12, inisialisasikan nilai i=0
10. Baris ke-13, inisialisasikan nilai j=-1
11. Baris ke-14, inisialisasikan nilai kmpNext[0]=-1, nilai kmpNext pada posisi 0,
pada setiap kali pemanggilan prosedur fungsi pinggiran nilai kmpNext[0]=-1
12. Baris ke-15, merupakan sebuah kondisi while-do, proses pengulangan while-
do akan berakhir jika kondisi dalam while-do tidak terpenuhi lagi. Nilai awal
pengulangan while(i<n-1) adalah while(0<8-1) atau while(0<7)
1) Posisi i=0
a. Baris ke-16, periksa kondisi while((j>=0) and (P[i]≠P[j]))
a) while((-1>=0) and („G‟≠‟0‟)) hasil kondisi false
b. Baris ke-19, tambahkan nilai i=i+1 atau i=0+1, nilai i=1
c. Baris ke-20, tambahkan nilai j=j+1 atau j=-1+1, nilai j=0
d. Baris ke-21, kondisi if(P[i]=P[j]) atau if(„C‟=‟G‟) hasil kondisi false
e. Baris ke-24, set nilai kmpNext[i]=j, nilai untuk kmpNext[1]=0
68
2) Posisi i=1
a. Baris ke-16, periksa kondisi while((j>=0) and (P[i]≠P[j]))
a) while((0>=0) and („C‟≠‟G‟)) hasil kondisi true. Baris ke-17
j=kmpNext[j] atau j=kmpNext[0], nilai j=-1
b) while((-1>=0) and („C‟≠‟0‟)) hasil kondisi false
b. Baris ke-19, tambahkan nilai i=i+1 atau i=1+1, nilai i=2
c. Baris ke-20, tambahkan nilai j=j+1 atau j=-1+1, nilai j=0
d. Baris ke-21, kondisi if(P[i]=P[j]) atau if(„A‟=‟G‟) hasil kondisi false
e. Baris ke-24, set nilai kmpNext[i]=j, nilai untuk kmpNext[2]=0
3) Posisi i=2
a. Baris ke-16, periksa kondisi while((j>=0) and (P[i]≠P[j]))
a) while((0>=0) and ('A'≠'G')) hasil kondisi true. Baris ke-17
j=kmpNext[j] atau j=kmpNext[0], nilai j=-1
b) while((-1>=0) and ('C'≠'0')) hasil kondisi false
b. Baris ke-19, tambahkan nilai i=i+1 atau i=2+1, nilai i=3
c. Baris ke-20, tambahkan nilai j=j+1 atau j=-1+1, nilai j=0
d. Baris ke-21, kondisi if(P[i]=P[j]) atau if('G'='G') hasil kondisi true
e. Baris ke-22, set nilai kmpNext[i]=kmpNext[j], nilai untuk
kmpNext[3]=-1
4) Posisi i=3
a. Baris ke-16, periksa kondisi while((j>=0) and (P[i]≠P[j]))
a) while((0>=0) and ('G'≠'G')) hasil kondisi false
b. Baris ke-19, tambahkan nilai i=i+1 atau i=3+1, nilai i=4
c. Baris ke-20, tambahkan nilai j=j+1 atau j=0+1, nilai j=1
d. Baris ke-21, kondisi if(P[i]=P[j]) atau if('A'='C') hasil kondisi false
e. Baris ke-24, set nilai kmpNext[i]=j, nilai untuk kmpNext[4]=1
5) Posisi i=4
a. Baris ke-16, periksa kondisi while((j>=0) and (P[i]≠P[j]))
a) while((1>=0) and ('A'≠'C')) hasil kondisi true. Baris ke-17
j=kmpNext[j] atau j=kmpNext[1], nilai j=0
69
b) while((0>=0) and ('A'≠'G')) hasil kondisi true. Baris ke-17
j=kmpNext[j] atau j=kmpNext[0], nilai j=-1
c) while((-1>=0) and ('A'≠'0')) hasil kondisi false
b. Baris ke-19, tambahkan nilai i=i+1 atau i=4+1, nilai i=5
c. Baris ke-20, tambahkan nilai j=j+1 atau j=-1+1, nilai j=0
d. Baris ke-21, kondisi if(P[i]=P[j]) atau if('G'='G') hasil kondisi true
e. Baris ke-22, set nilai kmpNext[i]=kmpNext[j], nilai untuk
kmpNext[2]=-1
6) Posisi i=5
a. Baris ke-16, periksa kondisi while((j>=0) and (P[i]≠P[j]))
a) while((0>=0) and ('G'≠'G')) hasil kondisi false
b. Baris ke-19, tambahkan nilai i=i+1 atau i=5+1, nilai i=6
c. Baris ke-20, tambahkan nilai j=j+1 atau j=-0+1, nilai j=1
d. Baris ke-21, kondisi if(P[i]=P[j]) atau if('A'='C') hasil kondisi false
e. Baris ke-24, set nilai kmpNext[i]=j, nilai untuk kmpNext[6]=1
7) Posisi i=6
a. Baris ke-16, periksa kondisi while((j>=0) and (P[i]≠P[j]))
a) while((1>=0) and ('A'≠'C')) hasil kondisi true. Baris ke-17
j=kmpNext[j] atau j=kmpNext[1], nilai j=0
b) while((0>=0) and ('A'≠'G')) hasil kondisi true. Baris ke-17
j=kmpNext[j] atau j=kmpNext[0], nilai j=-1
c) while((-1>=0) and ('A'≠'0')) hasil kondisi false
b. Baris ke-19, tambahkan nilai i=i+1 atau i=6+1, nilai i=7
c. Baris ke-20, tambahkan nilai j=j+1 atau j=-1+1, nilai j=0
d. Baris ke-21, kondisi if(P[i]=P[j]) atau if('G'='G') hasil kondisi true
e. Baris ke-22, set nilai kmpNext[i]=kmpNext[j], nilai untuk
kmpNext[7]=-1
8) Posisi i=7
Keluar dari while-do, karena tidak sesuai dengan kondisi while(i<7)
13. Baris ke-26, merupakan akhir dari perulangan while-do
70
Dari prosedur hitung pinggiran telah diperoleh tabel kmpNext, seperti
terlihat pada Tabel 4.1 berikut.
Tabel 4.1 Hasil tabel kmpNext
j 0 1 2 3 4 5 6 7
P[j] G C A G A G A G
kmpNext(j) -1 0 0 -1 1 -1 1 -1
Kemudian dilanjutkan dengan proses pencocokkan string menggunakan
algoritma knuth-morris-pratt. Sebelum penulis melakukan proses pencocokan
string, ada baiknya penulis ulang kembali tentang pseudocode algorirma kuth-
morris-pratt.
1. function KMPSearch( 2. input n : integer, { panjang pattern }
3. input m : integer, { panjang teks }
4. input P : string, { string pattern }
5. input T : string, { string teks }
6. ) boolean
7.
8. Deklarasi
9. i : integer { pointer dari teks }
10. j : integer { pointer dari pattern }
11. next : integer { menampung jumlah pergeseran }
12. ketemu : boolean { menampung nilai ketemu }
13. kmpNext : array[1..n] of integer
14. procedure HitungPinggiran(input n : integer, P : string,
output kmpNext : array[1..n] of integer)
15.
16. Algoritma
17. HitungPinggiran(m, P, kmpNext)
18. i := 0
19. next := 1
20. ketemu := false
21. while (i <= m - n) do
22. j := 0
23. while((j < n) and (T[i + j] == P[j])) do
24. j := j + 1
25. endwhile
26. if j >= n then
27. ketemu := true
28. next := j
29. else
30. next := j - kmpNext[j]
31. endif
32. i := i + next
71
33. endwhile
34. return ketemu
Langkah-langkah pencocokkan string menggunakan algoritma knuth-
morris-pratt sebagai berikut :
1. Baris ke-1 merupakan pemanggilan fungsi KMPSearch
2. Baris ke-2 merupakan sebuah masukan dari panjang pattern (n), diketahui
n=8
3. Baris ke-3 merupakan sebuah masukan dari panjang teks (m), diketahui m=24
4. Baris ke-4 merupakan sebuah masukan dari pattern (P), diketahui
P=GCAGAGAG. Isi dari pattern (P) ini yang akan di cari di sebuah teks (T)
5. Baris ke-5 merupakan sebuah masukan dari teks (T), diketahui
T=GCATCGCAGAGAGTATACAGTACG
6. Baris ke-6 menandakan bahwa fungsi KMPSearch ini akan menghasilkan nilai
boolean, true atau false. Jika true berarti proses pencocokan string ketemu,
dan jika false proses pencocokkan string tidak ketemu
7. Baris ke-8 merupakan sebuah komentar berisi Deklarasi
8. Baris ke-9, dideklarasikan pointer teks (i) dengan tipedata integer
9. Bari ke-10, dideklarasikan pointer pattern (j) dengan tipedata integer
10. Baris ke-11, dideklarasikan penampung jumlah pergeseran (next) dengan
tipedata integer
11. Baris ke-12, dideklarasikan ketemu dengan tipedata boolean
12. Baris ke-13, dideklarasikan tabel kmpNext dengan tipedata array integer,
dengan lebar array sama dengan panjang pattern (n)
13. Baris ke-14, dideklarasikan prosedur HitungPinggiran dengan masukan
panjang pattern (n), pattern (P) dan keluaran akan disimpan di variabel
kmpNext
14. Baris ke-16 merupakan sebuah komentar yang berisi Algoritma yang
menandakan akan dimulainya algoritma ini
15. Baris ke-17 merupakan pre-processing terhadap algoritma knuth-morris-pratt,
yang akan menjalankan prosedur HitungPinggiran, prosesnya sudah
dipaparkan dan nilai kmpNext seperti Tabel 4.1
72
16. Baris ke-18, inisialisasikan nilai i=0
17. Baris ke-19, inisialisasikan nilai nilsi next=1
18. Baris ke-20, inisialisasikan nilai ketemu=false
19. Baris ke-21 merupakan kondisi while-do, proses pengulangan while-do akan
berakhir jika kondisi dalam while-do tidak terpenuhi lagi. Nilai awal
perulangan while(i<=m-n) adalah while(0<=24-8) atau while(0<=16)
1) Posisi i=0
a. Baris ke-22, inisialisasikan nilai j=0
b. Baris ke-23, periksa kondisi while((j<n) and (T[i+j]==P[j]))
a) while(0<8 and „G‟=‟G‟) hasil kondisi true. Baris ke-24, j=j+1
atau j=0+1, nilai j=1
b) while(1<8 and „C‟=‟C‟) hasil kondisi true. Baris ke-24, j=j+1
atau j=1+1, nilai j=2
c) while(2<8 and „A‟=‟A‟) hasil kondisi true. Baris ke-24, j=j+1
atau j=2+1, nilai j=3
d) while(3<8 and „T‟=‟G‟) hasil kondisi false, keluar dari while-do,
nilai j=3
c. Baris ke-26, periksa kondisi if(j>=n) atau if(3>=8) hasil kondisi false
d. Baris ke-30, set nilai next=j-kmpNext[j] atau next=3-(-1), nilai next=4
e. Baris ke-32, tambahkan nilai i=i+next atau i=0+4, nilai i=4
2) Posisi i=4
a. Baris ke-22, inisialisasikan nilai j=0
b. Baris ke-23, periksa kondisi while((j<n) and (T[i+j]==P[j]))
a) while(0<8 and 'C'='G') hasil kondisi false, keluar dari while-do,
nilai j=0
c. Baris ke-26, periksa kondisi if(j>=n) atau if(0>=8) hasil kondisi false
d. Baris ke-30, set nilai next=j-kmpNext[j] atau next=0-(-1), nilai next=1
e. Baris ke-32, tambahkan nilai i=i+next atau i=4+1, nilai i=5
3) Posisi i=5
a. Baris ke-22, inisialisasikan nilai j=0
b. Baris ke-23, periksa kondisi while((j<n) and (T[i+j]==P[j]))
73
a) while(0<8 and 'G'='G') hasil kondisi true. Baris ke-24, j=j+1 atau
j=0+1, nilai j=1
b) while(1<8 and 'C'='C') hasil kondisi true. Baris ke-24, j=j+1 atau
j=1+1, nilai j=2
c) while(2<8 and 'A'='A') hasil kondisi true. Baris ke-24, j=j+1 atau
j=2+1, nilai j=3
d) while(3<8 and 'G'='G') hasil kondisi true. Baris ke-24, j=j+1 atau
j=3+1, nilai j=4
e) while(4<8 and 'A'='A') hasil kondisi true. Baris ke-24, j=j+1 atau
j=4+1, nilai j=5
f) while(5<8 and 'G'='G') hasil kondisi true. Baris ke-24, j=j+1 atau
j=5+1, nilai j=6
g) while(6<8 and 'A'='A') hasil kondisi true. Baris ke-24, j=j+1 atau
j=6+1, nilai j=7
h) while(7<8 and 'G'='G') hasil kondisi true. Baris ke-24, j=j+1 atau
j=7+1, nilai j=8
i) while(8<8 and 'T'='0') hasil kondisi false, keluar dari while-do,
nilai j=8
c. Baris ke-26, periksa kondisi if(j>=n) atau if(8>=8) hasil kondisi true
d. Baris ke-27, set nilai ketemu=true
e. Baris ke-28, set nilai next=j atau next=8, nilai next=8
f. Baris ke-32, tambahkan nilai i=i+next atau i=5+8, nilai i=13
4) Posisi i=13
a. Baris ke-22, inisialisasikan nilai j=0
b. Baris ke-23, periksa kondisi while((j<n) and (T[i+j]==P[j]))
a) while(0<8 and 'T'='G') hasil kondisi false, keluar dari while-do,
nilai j=0
c. Baris ke-26, periksa kondisi if(j>=n) atau if(0>=8) hasil kondisi false
d. Baris ke-30, set nilai next=j-kmpNext[j] atau next=0-(-1), nilai next=1
e. Baris ke-32, tambahkan nilai i=i+next atau i=13+1, nilai i=14
5) Posisi i=14
74
a. Baris ke-22, inisialisasikan nilai j=0
b. Baris ke-23, periksa kondisi while((j<n) and (T[i+j]==P[j]))
a) while(0<8 and 'A'='G') hasil kondisi false, keluar dari while-do,
nilai j=0
c. Baris ke-26, periksa kondisi if(j>=n) atau if(0>=8) hasil kondisi false
d. Baris ke-30, set nilai next=j-kmpNext[j] atau next=0-(-1), nilai next=0
e. Baris ke-32, tambahkan nilai i=i+next atau i=14+1, nilai i=15
6) Posisi i=15
a. Baris ke-22, inisialisasikan nilai j=0
b. Baris ke-23, periksa kondisi while((j<n) and (T[i+j]==P[j]))
a) while(0<8 and 'T'='G') hasil kondisi false, keluar dari while-do,
nilai j=0
c. Baris ke-26, periksa kondisi if(j>=n) atau if(0>=8) hasil kondisi false
d. Baris ke-30, set nilai next=j-kmpNext[j] atau next=0-(-1), nilai next=1
e. Baris ke-32, tambahkan nilai i=i+next atau i=15+1, nilai i=16
7) Posisi i=16
a. Baris ke-22, inisialisasikan nilai j=0
b. Baris ke-23, periksa kondisi while((j<n) and (T[i+j]==P[j]))
a) while(0<8 and 'A'='G') hasil kondisi false, keluar dari while-do,
nilai j=0
c. Baris ke-26, periksa kondisi if(j>=n) atau if(3>=8) hasil kondisi false
d. Baris ke-30, set nilai next=j-kmpNext[j] atau next=0-(-1), nilai next=1
e. Baris ke-32, tambahkan nilai i=i+next atau i=16+1, nilai i=17
8) Posisi i=17
Keluar dari while-do, karena tidak sesuai dengan kondisi while(i<=16)
20. Baris ke-34, hasil dari pencocokkan string ketemu dimana nilai ketemu=true
pada percobaan ke-3) posisi i=5
Kompleksitas waktunya adalah O(n+m), O(n) untuk mendapatkan tabel
kmpNext dengan menjalankan fungsi pinggiran dan O(m) untuk melakukan proses
pencocokkan string.
75
4.1.2.3 Analisis Algoritma Boyer-Moore
Dari uji coba tersebut, diperoleh keterangan dasar :
T = Teks : GCATCGCAGAGAGTATACAGTACG
P = Pattern : GCAGAGAG
m = Panjang dari teks (T) : 24
n = Panjang dari patten (P) : 8
Algoritma boyer-moore hampir sama seperti algoritma knuth-morris-pratt
dalam hal penyimpanan informasi untuk melakukan pergeseran yang berbeda
teletak pada arah mulai pencocokkan string-nya. Algoritma knuth-morris-pratt
melakukan awal pencocokkan string dimulai dari sebelah kiri sedangkan
algoritma boyer-moore melakukan awal pencocokkan string dimulai dari sebelah
kanan.
Sebelum melakukan proses pencocokkan string, algoritma boyer-moore
akan melakukan 2 (dua) buah pre-processing, yaitu bad-character dan good-
suffix. Bad-character akan menghitung banyaknya pergeseran yang harus
dilakukan berdasarkan identitas karakter yang menyebabkan kegagalan
pencocokkan string. Good-suffix akan menghitung banyaknya pergeseran yang
harus dilakukan, tetapi berdasarkan jumlah karakter yang berhasil dicocokkan
sebelum pencocokkan string tersebut gagal.
Kita akan mendapatkan tabel bmBC dengan menjalankan prosedur bad-
character. Sebelum menjalankan prosedur bad-character, ada baiknya penulis
ulang kembali pseudocode prosedur bad-character.
1. procedure BadCharacter( 2. input P : string, { string pattern } 3. input n : integer, { panjang pattern } 4. output bmBC : array[0..n-1] of integer { tabel bmBC } 5. ) 6. 7. Deklarasi
76
8. i : integer { pointer untuk awal tabel bmBC } 9. j : integer { pointer untuk akhir tabel bmBC } 10.
11. Algoritma
12. for(i := 0 to ASIZE-1)
13. bmBC[i] := -1;
14. endfor
15. for(j := 0 to n-1)
16. bmBC[P[j]] := n - j - 1
17. endfor
Kita akan mendapatkan nilai tabel bmBC dengan menjalankan prosedur
bad-character, langkah-langkahnya sebagai berikut :
1. Baris ke-1 merupakan pemanggilan prosedur BadCharacter
2. Baris ke-2 merupakan sebuah masukan dari pattern (P), diketahui
P=GCAGAGAG
3. Baris ke-3 merupakan sebuah masukan dari panjang pattern (n), diketahui
n=8
4. Baris ke-4 merupakan sebuah keluaran dari prosedur BadCharacter yang
disimpan pada variabel bmBC dengan tipedata array integer lebar array
berdasarkan panjang pattern (n)
5. Baris ke-7 merupakan sebuah komentar yang berisi Deklarasi
6. Baris ke-8, dideklarasikan pointer untuk nilai awal tabel bmBC (i) dengan
tipedata integer
7. Baris ke-9, dideklarasikan pointer untuk nilai akhir tabel bmBC (j) dengan
tipedata integer
8. Baris ke-11 merupakan sebuah komentar yang berisi Algoritma yang
menandakan akan dimulainya prosedur ini
9. Baris ke-12, merupakan sebuah kondisi for(), proses perulangan for() akan
berakhir jika kondisi dalam for() tidak terpenuhi lagi. Nilai awal pengulangan
for(i:=0 to ASIZE-1) adalah for(i:=0 to 255-1). ASIZE merupakan panjang
dari karakter alphabet, penulis menggunakan standar ASCII (American
Standard Code for Information Interchange) yaitu 255.
1) Baris ke-13, set nilai bmBC[i]=-1, bmBC[0]=-1, i=1
2) Baris ke-13, set nilai bmBC[i]=-1, bmBC[1]=-1, i=2
3) Baris ke-13, set nilai bmBC[i]=-1, bmBC[2]=-1, i=3
77
4) Baris ke-13, set nilai bmBC[i]=-1, bmBC[3]=-1, i=4
5) Baris ke-13, set nilai bmBC[i]=-1, bmBC[4]=-1, i=5
6) Baris ke-13, set nilai bmBC[i]=-1, bmBC[5]=-1, i=6
7) Baris ke-13, set nilai bmBC[i]=-1, bmBC[6]=-1, i=7
8) Baris ke-13, set nilai bmBC[i]=-1, bmBC[7]=-1, i=8
9) Baris ke-13, set nilai bmBC[i]=-1, bmBC[8]=-1, i=9
10) Baris ke-13, set nilai bmBC[i]=-1, bmBC[9]=-1, i=10
11) Baris ke-13, set nilai bmBC[i]=-1, bmBC[10]=-1, i=11
12) Baris ke-13, set nilai bmBC[i]=-1, bmBC[11]=-1, i=12
13) Baris ke-13, set nilai bmBC[i]=-1, bmBC[12]=-1, i=13
14) Baris ke-13, set nilai bmBC[i]=-1, bmBC[13]=-1, i=14
15) Baris ke-13, set nilai bmBC[i]=-1, bmBC[14]=-1, i=15
16) Baris ke-13, set nilai bmBC[i]=-1, bmBC[15]=-1, i=16
17) Baris ke-13, set nilai bmBC[i]=-1, bmBC[16]=-1, i=17
18) Baris ke-13, set nilai bmBC[i]=-1, bmBC[17]=-1, i=18
19) Baris ke-13, set nilai bmBC[i]=-1, bmBC[18]=-1, i=19
20) Baris ke-13, set nilai bmBC[i]=-1, bmBC[19]=-1, i= 20
21) Baris ke-13, set nilai bmBC[i]=-1, bmBC[20]=-1, i=21
22) Baris ke-13, set nilai bmBC[i]=-1, bmBC[21]=-1, i=22
23) Baris ke-13, set nilai bmBC[i]=-1, bmBC[22]=-1, i=23
24) Baris ke-13, set nilai bmBC[i]=-1, bmBC[23]=-1, i=24
25) Baris ke-13, set nilai bmBC[i]=-1, bmBC[24]=-1, i=25
26) Baris ke-13, set nilai bmBC[i]=-1, bmBC[25]=-1, i=26
27) Baris ke-13, set nilai bmBC[i]=-1, bmBC[26]=-1, i=27
28) Baris ke-13, set nilai bmBC[i]=-1, bmBC[27]=-1, i=28
29) Baris ke-13, set nilai bmBC[i]=-1, bmBC[28]=-1, i=29
30) Baris ke-13, set nilai bmBC[i]=-1, bmBC[29]=-1, i=30
31) Baris ke-13, set nilai bmBC[i]=-1, bmBC[30]=-1, i=31
32) Baris ke-13, set nilai bmBC[i]=-1, bmBC[31]=-1, i=32
33) Baris ke-13, set nilai bmBC[i]=-1, bmBC[32]=-1, i=33
34) Baris ke-13, set nilai bmBC[i]=-1, bmBC[33]=-1, i=34
35) Baris ke-13, set nilai bmBC[i]=-1, bmBC[34]=-1, i=35
36) Baris ke-13, set nilai bmBC[i]=-1, bmBC[35]=-1, i=36
37) Baris ke-13, set nilai bmBC[i]=-1, bmBC[36]=-1, i=37
38) Baris ke-13, set nilai bmBC[i]=-1, bmBC[37]=-1, i=38
39) Baris ke-13, set nilai bmBC[i]=-1, bmBC[38]=-1, i=39
40) Baris ke-13, set nilai bmBC[i]=-1, bmBC[39]=-1, i=40
41) Baris ke-13, set nilai bmBC[i]=-1, bmBC[40]=-1, i=41
42) Baris ke-13, set nilai bmBC[i]=-1, bmBC[41]=-1, i=42
43) Baris ke-13, set nilai bmBC[i]=-1, bmBC[42]=-1, i=43
44) Baris ke-13, set nilai bmBC[i]=-1, bmBC[43]=-1, i=44
45) Baris ke-13, set nilai bmBC[i]=-1, bmBC[44]=-1, i=45
46) Baris ke-13, set nilai bmBC[i]=-1, bmBC[45]=-1, i=46
47) Baris ke-13, set nilai bmBC[i]=-1, bmBC[46]=-1, i=47
48) Baris ke-13, set nilai bmBC[i]=-1, bmBC[47]=-1, i=48
49) Baris ke-13, set nilai bmBC[i]=-1, bmBC[48]=-1, i=49
78
50) Baris ke-13, set nilai bmBC[i]=-1, bmBC[49]=-1, i=50
51) Baris ke-13, set nilai bmBC[i]=-1, bmBC[50]=-1, i=51
52) Baris ke-13, set nilai bmBC[i]=-1, bmBC[51]=-1, i=52
53) Baris ke-13, set nilai bmBC[i]=-1, bmBC[52]=-1, i=53
54) Baris ke-13, set nilai bmBC[i]=-1, bmBC[53]=-1, i=54
55) Baris ke-13, set nilai bmBC[i]=-1, bmBC[54]=-1, i=55
56) Baris ke-13, set nilai bmBC[i]=-1, bmBC[55]=-1, i=56
57) Baris ke-13, set nilai bmBC[i]=-1, bmBC[56]=-1, i=57
58) Baris ke-13, set nilai bmBC[i]=-1, bmBC[57]=-1, i=58
59) Baris ke-13, set nilai bmBC[i]=-1, bmBC[58]=-1, i=59
60) Baris ke-13, set nilai bmBC[i]=-1, bmBC[59]=-1, i=60
61) Baris ke-13, set nilai bmBC[i]=-1, bmBC[60]=-1, i=61
62) Baris ke-13, set nilai bmBC[i]=-1, bmBC[61]=-1, i=62
63) Baris ke-13, set nilai bmBC[i]=-1, bmBC[62]=-1, i=63
64) Baris ke-13, set nilai bmBC[i]=-1, bmBC[63]=-1, i=64
65) Baris ke-13, set nilai bmBC[i]=-1, bmBC[64]=-1, i=65
66) Baris ke-13, set nilai bmBC[i]=-1, bmBC[65]=-1, i=66
67) Baris ke-13, set nilai bmBC[i]=-1, bmBC[66]=-1, i=67
68) Baris ke-13, set nilai bmBC[i]=-1, bmBC[67]=-1, i=68
69) Baris ke-13, set nilai bmBC[i]=-1, bmBC[68]=-1, i=69
70) Baris ke-13, set nilai bmBC[i]=-1, bmBC[69]=-1, i=70
71) Baris ke-13, set nilai bmBC[i]=-1, bmBC[70]=-1, i=71
72) Baris ke-13, set nilai bmBC[i]=-1, bmBC[71]=-1, i=72
73) Baris ke-13, set nilai bmBC[i]=-1, bmBC[72]=-1, i=73
74) Baris ke-13, set nilai bmBC[i]=-1, bmBC[73]=-1, i=74
75) Baris ke-13, set nilai bmBC[i]=-1, bmBC[74]=-1, i=75
76) Baris ke-13, set nilai bmBC[i]=-1, bmBC[75]=-1, i=76
77) Baris ke-13, set nilai bmBC[i]=-1, bmBC[76]=-1, i=77
78) Baris ke-13, set nilai bmBC[i]=-1, bmBC[77]=-1, i=78
79) Baris ke-13, set nilai bmBC[i]=-1, bmBC[78]=-1, i=79
80) Baris ke-13, set nilai bmBC[i]=-1, bmBC[79]=-1, i=80
81) Baris ke-13, set nilai bmBC[i]=-1, bmBC[80]=-1, i=81
82) Baris ke-13, set nilai bmBC[i]=-1, bmBC[81]=-1, i=82
83) Baris ke-13, set nilai bmBC[i]=-1, bmBC[82]=-1, i=83
84) Baris ke-13, set nilai bmBC[i]=-1, bmBC[83]=-1, i=84
85) Baris ke-13, set nilai bmBC[i]=-1, bmBC[84]=-1, i=85
86) Baris ke-13, set nilai bmBC[i]=-1, bmBC[85]=-1, i=86
87) Baris ke-13, set nilai bmBC[i]=-1, bmBC[86]=-1, i=87
88) Baris ke-13, set nilai bmBC[i]=-1, bmBC[87]=-1, i=88
89) Baris ke-13, set nilai bmBC[i]=-1, bmBC[88]=-1, i=89
90) Baris ke-13, set nilai bmBC[i]=-1, bmBC[89]=-1, i=90
91) Baris ke-13, set nilai bmBC[i]=-1, bmBC[90]=-1, i=91
92) Baris ke-13, set nilai bmBC[i]=-1, bmBC[91]=-1, i=92
93) Baris ke-13, set nilai bmBC[i]=-1, bmBC[92]=-1, i=93
94) Baris ke-13, set nilai bmBC[i]=-1, bmBC[93]=-1, i=94
95) Baris ke-13, set nilai bmBC[i]=-1, bmBC[94]=-1, i=95
79
96) Baris ke-13, set nilai bmBC[i]=-1, bmBC[95]=-1, i=96
97) Baris ke-13, set nilai bmBC[i]=-1, bmBC[96]=-1, i=97
98) Baris ke-13, set nilai bmBC[i]=-1, bmBC[97]=-1, i=98
99) Baris ke-13, set nilai bmBC[i]=-1, bmBC[98]=-1, i=99
100) Baris ke-13, set nilai bmBC[i]=-1, bmBC[99]=-1, i=100
101) Baris ke-13, set nilai bmBC[i]=-1, bmBC[100]=-1, i=101
102) Baris ke-13, set nilai bmBC[i]=-1, bmBC[101]=-1, i=102
103) Baris ke-13, set nilai bmBC[i]=-1, bmBC[102]=-1, i=103
104) Baris ke-13, set nilai bmBC[i]=-1, bmBC[103]=-1, i=104
105) Baris ke-13, set nilai bmBC[i]=-1, bmBC[104]=-1, i=105
106) Baris ke-13, set nilai bmBC[i]=-1, bmBC[105]=-1, i=106
107) Baris ke-13, set nilai bmBC[i]=-1, bmBC[106]=-1, i=107
108) Baris ke-13, set nilai bmBC[i]=-1, bmBC[107]=-1, i=108
109) Baris ke-13, set nilai bmBC[i]=-1, bmBC[108]=-1, i=109
110) Baris ke-13, set nilai bmBC[i]=-1, bmBC[109]=-1, i=110
111) Baris ke-13, set nilai bmBC[i]=-1, bmBC[110]=-1, i=111
112) Baris ke-13, set nilai bmBC[i]=-1, bmBC[111]=-1, i=112
113) Baris ke-13, set nilai bmBC[i]=-1, bmBC[112]=-1, i=113
114) Baris ke-13, set nilai bmBC[i]=-1, bmBC[113]=-1, i=114
115) Baris ke-13, set nilai bmBC[i]=-1, bmBC[114]=-1, i=115
116) Baris ke-13, set nilai bmBC[i]=-1, bmBC[115]=-1, i=116
117) Baris ke-13, set nilai bmBC[i]=-1, bmBC[116]=-1, i=117
118) Baris ke-13, set nilai bmBC[i]=-1, bmBC[117]=-1, i=118
119) Baris ke-13, set nilai bmBC[i]=-1, bmBC[118]=-1, i=119
120) Baris ke-13, set nilai bmBC[i]=-1, bmBC[119]=-1, i=120
121) Baris ke-13, set nilai bmBC[i]=-1, bmBC[120]=-1, i=121
122) Baris ke-13, set nilai bmBC[i]=-1, bmBC[121]=-1, i=122
123) Baris ke-13, set nilai bmBC[i]=-1, bmBC[122]=-1, i=123
124) Baris ke-13, set nilai bmBC[i]=-1, bmBC[123]=-1, i=124
125) Baris ke-13, set nilai bmBC[i]=-1, bmBC[124]=-1, i=125
126) Baris ke-13, set nilai bmBC[i]=-1, bmBC[125]=-1, i=126
127) Baris ke-13, set nilai bmBC[i]=-1, bmBC[126]=-1, i=127
128) Baris ke-13, set nilai bmBC[i]=-1, bmBC[127]=-1, i=128
129) Baris ke-13, set nilai bmBC[i]=-1, bmBC[128]=-1, i=129
130) Baris ke-13, set nilai bmBC[i]=-1, bmBC[129]=-1, i=130
131) Baris ke-13, set nilai bmBC[i]=-1, bmBC[130]=-1, i=131
132) Baris ke-13, set nilai bmBC[i]=-1, bmBC[131]=-1, i=132
133) Baris ke-13, set nilai bmBC[i]=-1, bmBC[132]=-1, i=133
134) Baris ke-13, set nilai bmBC[i]=-1, bmBC[133]=-1, i=134
135) Baris ke-13, set nilai bmBC[i]=-1, bmBC[134]=-1, i=135
136) Baris ke-13, set nilai bmBC[i]=-1, bmBC[135]=-1, i=136
137) Baris ke-13, set nilai bmBC[i]=-1, bmBC[136]=-1, i=137
138) Baris ke-13, set nilai bmBC[i]=-1, bmBC[137]=-1, i=138
139) Baris ke-13, set nilai bmBC[i]=-1, bmBC[138]=-1, i=139
140) Baris ke-13, set nilai bmBC[i]=-1, bmBC[139]=-1, i=140
141) Baris ke-13, set nilai bmBC[i]=-1, bmBC[140]=-1, i=141
80
142) Baris ke-13, set nilai bmBC[i]=-1, bmBC[141]=-1, i=142
143) Baris ke-13, set nilai bmBC[i]=-1, bmBC[142]=-1, i=143
144) Baris ke-13, set nilai bmBC[i]=-1, bmBC[143]=-1, i=144
145) Baris ke-13, set nilai bmBC[i]=-1, bmBC[144]=-1, i=145
146) Baris ke-13, set nilai bmBC[i]=-1, bmBC[145]=-1, i=146
147) Baris ke-13, set nilai bmBC[i]=-1, bmBC[146]=-1, i=147
148) Baris ke-13, set nilai bmBC[i]=-1, bmBC[147]=-1, i=148
149) Baris ke-13, set nilai bmBC[i]=-1, bmBC[148]=-1, i=149
150) Baris ke-13, set nilai bmBC[i]=-1, bmBC[149]=-1, i=150
151) Baris ke-13, set nilai bmBC[i]=-1, bmBC[150]=-1, i=151
152) Baris ke-13, set nilai bmBC[i]=-1, bmBC[151]=-1, i=152
153) Baris ke-13, set nilai bmBC[i]=-1, bmBC[152]=-1, i=153
154) Baris ke-13, set nilai bmBC[i]=-1, bmBC[153]=-1, i=154
155) Baris ke-13, set nilai bmBC[i]=-1, bmBC[154]=-1, i=155
156) Baris ke-13, set nilai bmBC[i]=-1, bmBC[155]=-1, i=156
157) Baris ke-13, set nilai bmBC[i]=-1, bmBC[156]=-1, i=157
158) Baris ke-13, set nilai bmBC[i]=-1, bmBC[157]=-1, i=158
159) Baris ke-13, set nilai bmBC[i]=-1, bmBC[158]=-1, i=159
160) Baris ke-13, set nilai bmBC[i]=-1, bmBC[159]=-1, i=160
161) Baris ke-13, set nilai bmBC[i]=-1, bmBC[160]=-1, i=161
162) Baris ke-13, set nilai bmBC[i]=-1, bmBC[161]=-1, i=162
163) Baris ke-13, set nilai bmBC[i]=-1, bmBC[162]=-1, i=163
164) Baris ke-13, set nilai bmBC[i]=-1, bmBC[163]=-1, i=164
165) Baris ke-13, set nilai bmBC[i]=-1, bmBC[164]=-1, i=165
166) Baris ke-13, set nilai bmBC[i]=-1, bmBC[165]=-1, i=166
167) Baris ke-13, set nilai bmBC[i]=-1, bmBC[166]=-1, i=167
168) Baris ke-13, set nilai bmBC[i]=-1, bmBC[167]=-1, i=168
169) Baris ke-13, set nilai bmBC[i]=-1, bmBC[168]=-1, i=169
170) Baris ke-13, set nilai bmBC[i]=-1, bmBC[169]=-1, i=170
171) Baris ke-13, set nilai bmBC[i]=-1, bmBC[170]=-1, i=171
172) Baris ke-13, set nilai bmBC[i]=-1, bmBC[171]=-1, i=172
173) Baris ke-13, set nilai bmBC[i]=-1, bmBC[172]=-1, i=173
174) Baris ke-13, set nilai bmBC[i]=-1, bmBC[173]=-1, i=174
175) Baris ke-13, set nilai bmBC[i]=-1, bmBC[174]=-1, i=175
176) Baris ke-13, set nilai bmBC[i]=-1, bmBC[175]=-1, i=176
177) Baris ke-13, set nilai bmBC[i]=-1, bmBC[176]=-1, i=177
178) Baris ke-13, set nilai bmBC[i]=-1, bmBC[177]=-1, i=178
179) Baris ke-13, set nilai bmBC[i]=-1, bmBC[178]=-1, i=179
180) Baris ke-13, set nilai bmBC[i]=-1, bmBC[179]=-1, i=180
181) Baris ke-13, set nilai bmBC[i]=-1, bmBC[180]=-1, i=181
182) Baris ke-13, set nilai bmBC[i]=-1, bmBC[181]=-1, i=182
183) Baris ke-13, set nilai bmBC[i]=-1, bmBC[182]=-1, i=183
184) Baris ke-13, set nilai bmBC[i]=-1, bmBC[183]=-1, i=184
185) Baris ke-13, set nilai bmBC[i]=-1, bmBC[184]=-1, i=185
186) Baris ke-13, set nilai bmBC[i]=-1, bmBC[185]=-1, i=186
187) Baris ke-13, set nilai bmBC[i]=-1, bmBC[186]=-1, i=187
81
188) Baris ke-13, set nilai bmBC[i]=-1, bmBC[187]=-1, i=188
189) Baris ke-13, set nilai bmBC[i]=-1, bmBC[188]=-1, i=189
190) Baris ke-13, set nilai bmBC[i]=-1, bmBC[189]=-1, i=190
191) Baris ke-13, set nilai bmBC[i]=-1, bmBC[190]=-1, i=191
192) Baris ke-13, set nilai bmBC[i]=-1, bmBC[191]=-1, i=192
193) Baris ke-13, set nilai bmBC[i]=-1, bmBC[192]=-1, i=193
194) Baris ke-13, set nilai bmBC[i]=-1, bmBC[193]=-1, i=194
195) Baris ke-13, set nilai bmBC[i]=-1, bmBC[194]=-1, i=195
196) Baris ke-13, set nilai bmBC[i]=-1, bmBC[195]=-1, i=196
197) Baris ke-13, set nilai bmBC[i]=-1, bmBC[196]=-1, i=197
198) Baris ke-13, set nilai bmBC[i]=-1, bmBC[197]=-1, i=198
199) Baris ke-13, set nilai bmBC[i]=-1, bmBC[198]=-1, i=199
200) Baris ke-13, set nilai bmBC[i]=-1, bmBC[199]=-1, i=200
201) Baris ke-13, set nilai bmBC[i]=-1, bmBC[200]=-1, i=201
202) Baris ke-13, set nilai bmBC[i]=-1, bmBC[201]=-1, i=202
203) Baris ke-13, set nilai bmBC[i]=-1, bmBC[202]=-1, i=203
204) Baris ke-13, set nilai bmBC[i]=-1, bmBC[203]=-1, i=204
205) Baris ke-13, set nilai bmBC[i]=-1, bmBC[204]=-1, i=205
206) Baris ke-13, set nilai bmBC[i]=-1, bmBC[205]=-1, i=206
207) Baris ke-13, set nilai bmBC[i]=-1, bmBC[206]=-1, i=207
208) Baris ke-13, set nilai bmBC[i]=-1, bmBC[207]=-1, i=208
209) Baris ke-13, set nilai bmBC[i]=-1, bmBC[208]=-1, i=209
210) Baris ke-13, set nilai bmBC[i]=-1, bmBC[209]=-1, i=210
211) Baris ke-13, set nilai bmBC[i]=-1, bmBC[210]=-1, i=211
212) Baris ke-13, set nilai bmBC[i]=-1, bmBC[211]=-1, i=212
213) Baris ke-13, set nilai bmBC[i]=-1, bmBC[212]=-1, i=213
214) Baris ke-13, set nilai bmBC[i]=-1, bmBC[213]=-1, i=214
215) Baris ke-13, set nilai bmBC[i]=-1, bmBC[214]=-1, i=215
216) Baris ke-13, set nilai bmBC[i]=-1, bmBC[215]=-1, i=216
217) Baris ke-13, set nilai bmBC[i]=-1, bmBC[216]=-1, i=217
218) Baris ke-13, set nilai bmBC[i]=-1, bmBC[217]=-1, i=218
219) Baris ke-13, set nilai bmBC[i]=-1, bmBC[218]=-1, i=219
220) Baris ke-13, set nilai bmBC[i]=-1, bmBC[219]=-1, i=220
221) Baris ke-13, set nilai bmBC[i]=-1, bmBC[220]=-1, i=221
222) Baris ke-13, set nilai bmBC[i]=-1, bmBC[221]=-1, i=222
223) Baris ke-13, set nilai bmBC[i]=-1, bmBC[222]=-1, i=223
224) Baris ke-13, set nilai bmBC[i]=-1, bmBC[223]=-1, i=224
225) Baris ke-13, set nilai bmBC[i]=-1, bmBC[224]=-1, i=225
226) Baris ke-13, set nilai bmBC[i]=-1, bmBC[225]=-1, i=226
227) Baris ke-13, set nilai bmBC[i]=-1, bmBC[226]=-1, i=227
228) Baris ke-13, set nilai bmBC[i]=-1, bmBC[227]=-1, i=228
229) Baris ke-13, set nilai bmBC[i]=-1, bmBC[228]=-1, i=229
230) Baris ke-13, set nilai bmBC[i]=-1, bmBC[229]=-1, i=230
231) Baris ke-13, set nilai bmBC[i]=-1, bmBC[230]=-1, i=231
232) Baris ke-13, set nilai bmBC[i]=-1, bmBC[231]=-1, i=232
233) Baris ke-13, set nilai bmBC[i]=-1, bmBC[232]=-1, i=233
82
234) Baris ke-13, set nilai bmBC[i]=-1, bmBC[233]=-1, i=234
235) Baris ke-13, set nilai bmBC[i]=-1, bmBC[234]=-1, i=235
236) Baris ke-13, set nilai bmBC[i]=-1, bmBC[235]=-1, i=236
237) Baris ke-13, set nilai bmBC[i]=-1, bmBC[236]=-1, i=237
238) Baris ke-13, set nilai bmBC[i]=-1, bmBC[237]=-1, i=238
239) Baris ke-13, set nilai bmBC[i]=-1, bmBC[238]=-1, i=239
240) Baris ke-13, set nilai bmBC[i]=-1, bmBC[239]=-1, i=240
241) Baris ke-13, set nilai bmBC[i]=-1, bmBC[240]=-1, i=241
242) Baris ke-13, set nilai bmBC[i]=-1, bmBC[241]=-1, i=242
243) Baris ke-13, set nilai bmBC[i]=-1, bmBC[242]=-1, i=243
244) Baris ke-13, set nilai bmBC[i]=-1, bmBC[243]=-1, i=244
245) Baris ke-13, set nilai bmBC[i]=-1, bmBC[244]=-1, i=245
246) Baris ke-13, set nilai bmBC[i]=-1, bmBC[245]=-1, i=246
247) Baris ke-13, set nilai bmBC[i]=-1, bmBC[246]=-1, i=247
248) Baris ke-13, set nilai bmBC[i]=-1, bmBC[247]=-1, i=248
249) Baris ke-13, set nilai bmBC[i]=-1, bmBC[248]=-1, i=249
250) Baris ke-13, set nilai bmBC[i]=-1, bmBC[249]=-1, i=250
251) Baris ke-13, set nilai bmBC[i]=-1, bmBC[250]=-1, i=251
252) Baris ke-13, set nilai bmBC[i]=-1, bmBC[251]=-1, i=252
253) Baris ke-13, set nilai bmBC[i]=-1, bmBC[252]=-1, i=253
254) Baris ke-13, set nilai bmBC[i]=-1, bmBC[253]=-1, i=254
255) Baris ke-13, set nilai bmBC[i]=-1, bmBC[254]=-1, i=255
256) Baris ke-13, set nilai bmBC[i]=-1, bmBC[255]=-1, i=256
10. Baris ke-15, merupakan sebuah kondisi for() untuk mendapatkan tabel nilai
bmBC. Nilai awal pengulangan for(j:=0 to n-1) adalah for(j:=0 to 8-1) atau
for(j:=0 to 7)
1) Baris ke-16, set nilai bmBC[P[j]]=n-j-1 atau bmBC[P[0]]=8-0-1, nilai
bmBC[„G‟]=7
2) Baris ke-16, set nilai bmBC[P[j]]=n-j-1 atau bmBC[P[0]]=8-1-1, nilai
bmBC[„C‟]=6
3) Baris ke-16, set nilai bmBC[P[j]]=n-j-1 atau bmBC[P[0]]=8-2-1, nilai
bmBC[„A‟]=5
4) Baris ke-16, set nilai bmBC[P[j]]=n-j-1 atau bmBC[P[0]]=8-3-1, nilai
bmBC[„G‟]=4
5) Baris ke-16, set nilai bmBC[P[j]]=n-j-1 atau bmBC[P[0]]=8-4-1, nilai
bmBC[„A‟]=3
6) Baris ke-16, set nilai bmBC[P[j]]=n-j-1 atau bmBC[P[0]]=8-5-1, nilai
bmBC[„G‟]=2
83
7) Baris ke-16, set nilai bmBC[P[j]]=n-j-1 atau bmBC[P[0]]=8-6-1, nilai
bmBC[„A‟]=1
8) Baris ke-16, set nilai bmBC[P[j]]=n-j-1 atau bmBC[P[0]]=8-7-1, nilai
bmBC[„G‟]=0
Dari prosedur bad-character telah diperoleh tabel bmBC, seperti terlihat
pada Tabel 4.2 berikut.
Tabel 4.2 Hasil tabel bmBC
karakter A C G
bmBC 1 6 2
Selanjutnya kita akan mendapatkan tabel nilai bmGS dengan cara
menjalankan prosedur good-suffix, tetapi sebelum mendapatkan nilai bmGS kita
perlu mendapatkan tabel nilai suff dari suatu pattern (P). Untuk mendapatkan
tabel nilai suff kita perlu menjalankan prosedur suffix, sebelum menjalankan
prosedur suffix alangkah baiknya penulis ulangi kembali pseudocode dari prosedur
suffix.
1. procedure Suffix (
2. input P : string, { string pattern }
3. input n : integer, { panjang pattern }
4. output suff : array[0..n-1] of integer { tabel suff }
5. )
6.
7. Deklarasi
8. f : integer { pointer suffix pattern }
9. g : integer { pointer pajang suffix pattern }
10. j : integer { pointer dari pattern }
11.
12. Algoritma
13. suff[n-1] := n
14. f := 0
15. g := n - 1
16. for(j := n - 2 downto 0)
17. if(j > g and (suff[j + n - 1 - f] < j - g))
18. suff[j] := suff[j + n - 1 - f]
19. else
20. if(j < g)
21. g := j
84
22. endif
23. f := j
24. while(g >= 0 and P[g] = P[g + n - 1 - f])
25. g := g - 1
26. endwhile
27. suff[j] := f - g
28. endif
29. endfor
Kita akan mendapatkan tabel nilai suff dengan menjalankan prosedur suffix,
langkah-langkahnya sebagai berikut :
1. Baris ke-1 merupakan pemanggilan prosedur Suffix
2. Baris ke-2 merupakan sebuah masukan dari pattern (P), diketahui
P=GCAGAGAG
3. Baris ke-3 merupakan sebuah masukan dari panjang pattern (n), diketahui
n=8
4. Baris ke-4 merupakan hasil keluaran dari prosedur Suffix yang disimpan pada
suff dengan tipedata array integer lebar array berdasarkan panjang pattern (n)
5. Baris ke-7 merupakan sebuah komentar yang berisi Deklarasi
6. Baris ke-8, dideklarasikan pointer suffix pattern (f) dengan tipedata integer
7. Baris ke-9, dideklarasikan pointer panjang suffix pattern (g) dengan tipedata
integer
8. Baris ke-10, dideklarasikan pointer pattern(j) dengan tipedata integer
9. Baris ke-12 merupakan sebuah komentar yang berisi Algoritma yang
menandakan akan dimulainya prosedur ini
10. Baris ke-13, set nilai suff[n-1]=n atau suff[8-1]=8, nilai suff[7]=8
11. Baris ke-14, inisialisasikan f=0
12. Baris ke-15, set nilai g=n-1 atau g=8-1, nilai g=7
13. Baris ke-16, merupakan sebuah kondisi for(), proses perulangan for() akan
berakhir jika kondisi dalam for() tidak terpenuhi lagi. Nilai awal pengulangan
for(j=n-2 downto 0) adalah for(j=8-2 downto 0) atau for(j=6 downto 0)
1) Posisi j=6
85
a. Baris ke-17, periksa kondisi if(j>g and (suff[j+n-1-f] < j-g), if(6>7
and (suff[6+8-1-0] < 6-7)) atau if(6>7 and suff[13]<-1), hasil kondisi
false
b. Baris ke-19, periksa kondisi if(j<g), if(6<7), hasil kondisi true
c. Baris ke-21, set nilai g=j, g=6
d. Baris ke-23, set nilai f=j, f=6
e. Baris ke-24, periksa kondisi while(g>=0 and P[g]=P[g+n-1-f])
a) while(6>=0 and P[6]=P[7]) atau while(6>=0 and „A‟=‟G‟), hasil
kondisi false
f. Baris ke-27, set nilai suff[i]=f-g, suff[6]=6-6, nilai suff[6]=0, g=6, f=6
2) Posisi j=5
a. Baris ke-17, periksa kondisi if(j>g and (suff[j+n-1-f] < j-g), if(5>6
and (suff[5+8-1-6] < 5-6)) atau if(5>6 and suff[6]<-1), hasil kondisi
false
b. Baris ke-19, periksa kondisi if(j<g), if(5<6), hasil kondisi true
c. Baris ke-21, set nilai g=j, g=5
d. Baris ke-23, set nilai f=j, f=5
e. Baris ke-24, periksa kondisi while(g>=0 and P[g]=P[g+n-1-f])
a) while(5>=0 and P[5]=P[7]) atau while(5>=0 and „G‟=‟G‟), hasil
kondisi true. Baris ke-25, set nilai g=g-1 atau g=5-1, nilai g=4
b) while(4>=0 and P[4]=P[6]) atau while(4>=0 and „A‟=‟A‟), hasil
kondisi true. Baris ke-25, set nilai g=g-1 atau g=4-1, nilai g=3
c) while(3>=0 and P[3]=P[5]) atau while(3>=0 and „G‟=‟G‟), hasil
kondisi true. Baris ke-25, set nilai g=g-1 atau g=3-1, nilai g=2
d) while(2>=0 and P[2]=P[4]) atau while(2>=0 and „A‟=‟A‟), hasil
kondisi true. Baris ke-25, set nilai g=g-1 atau g=2-1, nilai g=1
e) while(1>=0 and P[1]=P[3]) atau while(1>=0 and „C‟=‟G‟), hasil
kondisi false, nilai g=1
f. Baris ke-27, set nilai suff[i]=f-g, suff[5]=5-1, nilai suff[5]=4, g=1, f=5
3) Posisi j=4
86
a. Baris ke-17, periksa kondisi if(j>g and (suff[j+n-1-f] < j-g), if(4>1
and (suff[4+8-1-5] < 4-1)) atau if(4>1 and suff[6]<3), hasil kondisi
true
b. Baris ke-18, set nilai suff[j]=suff[j+n-1-f], suff[4]=suff[4+8-1-5] atau
suff[4]=suff[6], nilai suff[4]=0, g=1, f=5
4) Posisi j=3
a. Baris ke-17, periksa kondisi if(j>g and (suff[j+n-1-f] < j-g), if(3>1
and (suff[3+8-1-5] < 3-1)) atau if(3>1 and suff[5]<2), hasil kondisi
false
b. Baris ke-19, periksa kondisi if(j<g), if(3<1), hasil kondisi false
c. Baris ke-23, set nilai f=j, f=3
d. Baris ke-24, periksa kondisi while(g>=0 and P[g]=P[g+n-1-f])
a) while(1>=0 and P[1]=P[6]) atau while(1>=0 and „C‟=‟A‟), hasil
kondisi false
e. Baris ke-27, set nilai suff[i]=f-g, suff[3]=3-1, nilai suff[6]=2, g=1, f=3
5) Posisi j=2
a. Baris ke-17, periksa kondisi if(j>g and (suff[j+n-1-f] < j-g), if(2>1
and (suff[2+8-1-3] < 2-1)) atau if(2>1 and suff[6]<1), hasil kondisi
true
b. Baris ke-18, set nilai suff[j]=suff[j+n-1-f], suff[2]=suff[2+8-1-3] atau
suff[2]=suff[6], nilai suff[2]=0, g=1, f=3
6) Posisi j=1
a. Baris ke-17, periksa kondisi if(j>g and (suff[j+n-1-f] < j-g), if(1>1
and (suff[1+8-1-3] < 1-1)) atau if(1>1 and suff[5]<0), hasil kondisi
false
b. Baris ke-19, periksa kondisi if(j<g), if(1<1), hasil kondisi false
c. Baris ke-23, set nilai f=j, f=1
d. Baris ke-24, periksa kondisi while(g>=0 and P[g]=P[g+n-1-f])
a) while(1>=0 and P[1]=P[7]) atau while(1>=0 and „C‟=‟G‟), hasil
kondisi false
e. Baris ke-27, set nilai suff[i]=f-g, suff[1]=1-1, nilai suff[1]=0, g=1, f=1
87
7) Posisi j=0
a. Baris ke-17, periksa kondisi if(j>g and (suff[j+n-1-f] < j-g), if(0>1
and (suff[0+8-1-1] < 0-1)) atau if(0>1 and suff[6]<-1), hasil kondisi
false
b. Baris ke-19, periksa kondisi if(j<g), if(0<1), hasil kondisi false
c. Baris ke-21, set nilai g=j, g=0
d. Baris ke-23, set nilai f=j, f=0
e. Baris ke-24, periksa kondisi while(g>=0 and P[g]=P[g+n-1-f])
a) while(0>=0 and P[0]=P[7]) atau while(0>=0 and „G‟=‟G‟), hasil
kondisi true
b) while(-1>=0 and P[-1]=P[6]) atau while(1>=0 and „0‟=‟A‟),
hasil kondisi false, nilai g=-1
f. Baris ke-27, set nilai suff[i]=f-g, suff[3]=0-(-1), nilai suff[0]=1
14. Baris ke-29, merupakan akhir dari perulangan for()
Dari prosedur suffix telah diperoleh tabel nilai suff, seperti terlihat pada
Tabel 4.3 berikut.
Tabel 4.3 Hasil tabel suff
j 0 1 2 3 4 5 6 7
P[j] G C A G A G A G
suff[j] 1 0 0 2 0 4 0 8
Setelah tabel nilai suff didapatkan, kita akan menjalankan prosedur good-
suffix untuk mendapatkan tabel nilai bmGS. Sebelum memulai proses
mendapatkan tabel nilai bmGS ada baiknya penulis ulang kembali pseudocode
prosedur good-suffix.
1. procedure GoodSuffix(
2. input P : string, { string pattern }
3. input n : integer, { panjang pattern }
4. output bmGS : array[0..n-1] of integer { tabel bmGS }
5. )
6.
7. Deklarasi
88
8. i : integer { pointer pattern }
9. j : integer { pointer untuk bmGS }
10. suff : array[0..n-1] of integer { temp suff }
11. procedure Suffix(input P : string, input n : integer,
output suff : array[1..n] of integer)
12.
13. Algoritma
14. Suffix(P, n, suff)
15. for(i := 0 to n - 1)
16. bmGS[i] := n
17. endfor
18. j := 0
19. for(i := n -1 downto -1)
20. if(i == -1 or suff[i] == i + 1)
21. for(j := 0 to n - 2 - i )
22. if(bmGS[j] = n)
23. bmGS[j] := n - 1 - i
24. endif
25. endfor
26. endif
27. endfor
28. for(i := 0 to n - 2)
29. bmGS[n - 1 - suff[i]] := n - 1 - i
30. endfor
Kita akan mendapatkan tabel nilai bmGS dengan menjalankan prosedur
good-suffix, langkah-langkahnya sebagai berikut :
1. Baris ke-1 merupakan pemanggilan prosedur GoodSuffix
2. Baris ke-2 merupakan sebuah masukan dari pattern (P), diketahui
P=GCAGAGAG
3. Baris ke-3 merupakan sebuah masukan dari panjang pattern (n), diketahui
n=8
4. Baris ke-4 merupakan hasil keluaran dari prosedur GoodSuffix yang disimpan
pada bmGS dengan tipedata array integer lebar array berdasarkan panjang
pattern (n)
5. Baris ke-7 merupakan sebuah komentar yang berisi Deklarasi
6. Baris ke-8, dideklarasikan pointer pattern (i) dengan tipedata integer
7. Baris ke-9, dideklarasikan pointer untuk bmGS (j) dengan tipedata integer
8. Baris ke-10, dideklarasikan suff dengan tipedata array integer, dengan lebar
array sama dengan panjang pattern (n)
9. Baris ke-11, dideklarasikan prosedur Suffix dengan masukan pattern (P),
panjang pattern (n) dan keluaran akan disimpan di variable suff
89
10. Baris ke-12 merupakan sebuah komentar yang berisi Algoritma yang
menandakan akan dimulainya prosedur ini
11. Baris ke-14 merupakan prosedur Suffix, prosedur Suffix akan menghasilkan
tabel nilai suff, prosesnya sudah dipaparkan dan nilai suff seperti Tabel 4.3
12. Baris ke-15, merupakan sebuah kondisi for(), proses perulangan for() akan
berakhir jika kondisi dalam for() tidak terpenuhi lagi. Nilai awal pengulangan
for(i:=0 to n-1) adalah for(i=0 to 8-1) atau for(i=0 to 7)
1) Posisi i=0
Baris ke-16, set nilai bmGS[i]=n, nilai bmGS[0]=8
2) Posisi i=1
Baris ke-16, set nilai bmGS[i]=n, nilai bmGS[1]=8
3) Posisi i=2
Baris ke-16, set nilai bmGS[i]=n, nilai bmGS[2]=8
4) Posisi i=3
Baris ke-16, set nilai bmGS[i]=n, nilai bmGS[3]=8
5) Posisi i=4
Baris ke-16, set nilai bmGS[i]=n, nilai bmGS[4]=8
6) Posisi i=5
Baris ke-16, set nilai bmGS[i]=n, nilai bmGS[5]=8
7) Posisi i=6
Baris ke-16, set nilai bmGS[i]=n, nilai bmGS[6]=8
8) Posisi i=7
Baris ke-16, set nilai bmGS[i]=n, nilai bmGS[7]=8
13. Baris ke-18, set nilai j=0
14. Baris ke-19, merupakan sebuah kondisi for(), proses pengulangan for() akan
berakhir jika kondisi dalam for() tidak terpenuhi lagi. Nilai awal pengulangan
for(i:=n-1 downto -1) adalah for(i=8-1 downto -1) atau for(i=7 downto -1)
1) Posisi i=7
a. Baris ke-20, kondisi if(i=-1 or suff[i]=i+1), if(7=-1 or suff[7]=7+1)
atau if(7=-1 or 8=8), hasil kondisi true
90
a) Baris ke-21, merupakan kondisi for(), nilai awal pengulangan
for(j:=0 to n-2-i) adalah for(j=0 to 8-2-7) atau for(j=0 to -1) hasil
kondisi false
2) Posisi i=6
a. Baris ke-20, kondisi if(i=-1 or suff[i]=i+1), if(6=-1 or suff[6]=6+1)
atau if(6=-1 or 0=7), hasil kondisi false
3) Posisi i=5
a. Baris ke-20, kondisi if(i=-1 or suff[i]=i+1), if(5=-1 or suff[5]=5+1)
atau if(5=-1 or 4=6), hasil kondisi false
4) Posisi i=4
a. Baris ke-20, kondisi if(i=-1 or suff[i]=i+1), if(4=-1 or suff[4]=4+1)
atau if(4=-1 or 0=5), hasil kondisi false
5) Posisi i=3
a. Baris ke-20, kondisi if(i=-1 or suff[i]=i+1), if(3=-1 or suff[3]=3+1)
atau if(3=-1 or 2=4), hasil kondisi false
6) Posisi i=2
a. Baris ke-20, kondisi if(i=-1 or suff[i]=i+1), if(2=-1 or suff[2]=2+1)
atau if(2=-1 or 0=3), hasil kondisi false
7) Posisi i=1
a. Baris ke-20, kondisi if(i=-1 or suff[i]=i+1), if(1=-1 or suff[1]=1+1)
atau if(1=-1 or 0=2), hasil kondisi false
8) Posisi i=0
a. Baris ke-20, kondisi if(i=-1 or suff[i]=i+1), if(0=-1 or suff[0]=0+1)
atau if(0=-1 or 1=1), hasil kondisi true
a) Baris ke-21, merupakan kondisi for(), nilai awal pengulangan
for(j:=0 to n-2-i) adalah for(j=0 to 8-2-0) atau for(j=0 to 6) hasil
kondisi true
1. Posisi j=0
1) Baris ke-22, kondisi if(bmGS[j]=n) adalah if(bmGS[0]=8)
atau if(8=8) hasil kondisi true
91
2) Baris ke-23, set nilai bmGS[j]=n-1-i, bmGS[0]=8-1-0 atau
bmGS[0]=7
2. Posisi j=1
1) Baris ke-22, kondisi if(bmGS[j]=n) adalah if(bmGS[1]=8)
atau if(8=8) hasil kondisi true
2) Baris ke-23, set nilai bmGS[j]=n-1-i, bmGS[1]=8-1-0 atau
bmGS[1]=7
3. Posisi j=2
1) Baris ke-22, kondisi if(bmGS[j]=n) adalah if(bmGS[2]=8)
atau if(8=8) hasil kondisi true
2) Baris ke-23, set nilai bmGS[j]=n-1-i, bmGS[2]=8-1-0 atau
bmGS[2]=7
4. Posisi j=3
1) Baris ke-22, kondisi if(bmGS[j]=n) adalah if(bmGS[3]=8)
atau if(8=8) hasil kondisi true
2) Baris ke-23, set nilai bmGS[j]=n-1-i, bmGS[3]=8-1-0 atau
bmGS[3]=7
5. Posisi j=4
1) Baris ke-22, kondisi if(bmGS[j]=n) adalah if(bmGS[4]=8)
atau if(8=8) hasil kondisi true
2) Baris ke-23, set nilai bmGS[j]=n-1-i, bmGS[4]=8-1-0 atau
bmGS[4]=7
6. Posisi j=5
1) Baris ke-22, kondisi if(bmGS[j]=n) adalah if(bmGS[5]=8)
atau if(8=8) hasil kondisi true
2) Baris ke-23, set nilai bmGS[j]=n-1-i, bmGS[5]=8-1-0 atau
bmGS[5]=7
7. Posisi j=6
1) Keluar dari kondisi for()
9) Posisi i=-1
92
a. Baris ke-20, kondisi if(i=-1 or suff[i]=i+1), if(-1=-1 or suff[-1]=-
1+1) atau if(-1=-1 or 0=0), hasil kondisi true
a) Baris ke-21, merupakan kondisi for(), nilai awal pengulangan
for(j:=0 to n-2-i) adalah for(j=0 to 8-2-(-1)) atau for(j=0 to 7) hasil
kondisi true
1. Posisi j=0
1) Baris ke-22, kondisi if(bmGS[j]=n) adalah if(bmGS[0]=8)
atau if(7=8) hasil kondisi false
2. Posisi j=1
1) Baris ke-22, kondisi if(bmGS[j]=n) adalah if(bmGS[1]=8)
atau if(7=8) hasil kondisi false
3. Posisi j=2
1) Baris ke-22, kondisi if(bmGS[j]=n) adalah if(bmGS[2]=8)
atau if(7=8) hasil kondisi false
4. Posisi j=3
1) Baris ke-22, kondisi if(bmGS[j]=n) adalah if(bmGS[3]=8)
atau if(7=8) hasil kondisi false
5. Posisi j=4
1) Baris ke-22, kondisi if(bmGS[j]=n) adalah if(bmGS[4]=8)
atau if(7=8) hasil kondisi false
6. Posisi j=5
1) Baris ke-22, kondisi if(bmGS[j]=n) adalah if(bmGS[5]=8)
atau if(7=8) hasil kondisi false
7. Posisi j=6
1) Baris ke-22, kondisi if(bmGS[j]=n) adalah if(bmGS[6]=8)
atau if(8=8) hasil kondisi true
2) Baris ke-23, set nilai bmGS[j]=n-1-i, bmGS[6]=8-1-(-1)
atau bmGS[6]=8
8. Posisi j=7
1) Keluar dari kondisi for()
93
15. Baris ke-28, merupakan sebuah kondisi for(), proses perulangan for() akan
berakhir jika kondisi dalam for() tidak terpenuhi lagi. Nilai awal pengulangan
for(i:=0 to n-2) adalah for (i=0 to 8-2) atau for(i=0 to 6)
1) Posisi i=0
a. Baris ke-29, set nilai bmGS[n-1-suff[i]]:=n-1-i, bmGS[8-1-suff[0]=8-
1-0, bmGS[7-1]=7, nilai bmGS[6]=7
2) Posisi i=1
a. Baris ke-29, set nilai bmGS[n-1-suff[i]]:=n-1-i, bmGS[8-1-suff[1]=8-
1-1, bmGS[7-0]=6, nilai bmGS[7]=6
3) Posisi i=2
a. Baris ke-29, set nilai bmGS[n-1-suff[i]]:=n-1-i, bmGS[8-1-suff[2]=8-
1-2, bmGS[7-0]=5, nilai bmGS[7]=5
4) Posisi i=3
a. Baris ke-29, set nilai bmGS[n-1-suff[i]]:=n-1-i, bmGS[8-1-suff[3]=8-
1-3, bmGS[7-2]=4, nilai bmGS[5]=4
5) Posisi i=4
a. Baris ke-29, set nilai bmGS[n-1-suff[i]]:=n-1-i, bmGS[8-1-suff[4]=8-
1-4, bmGS[7-0]=3, nilai bmGS[7]=3
6) Posisi i=5
a. Baris ke-29, set nilai bmGS[n-1-suff[i]]:=n-1-i, bmGS[8-1-suff[5]=8-
1-5, bmGS[7-4]=2, nilai bmGS[3]=2
7) Posisi i=6
a. Baris ke-29, set nilai bmGS[n-1-suff[i]]:=n-1-i, bmGS[8-1-suff[6]=8-
1-6, bmGS[7-0]=1, nilai bmGS[7]=1
8) Posisi i=7
a) Keluar dari kondisi for()
94
Dari prosedur good-suffix telah diperoleh tabel nilai bmGS, seperti terlihat
pada Tabel 4.4 berikut.
Tabel 4.4 Hasil tabel bmGS
j 0 1 2 3 4 5 6 7
P[j] G C A G A G A G
bmGS[j] 7 7 7 2 7 4 7 1
Kemudian dilanjutkan dengan proses pencocokkan string menggunakan
algoritma boyer-moore. Sebelum penulis melakukan proses pencocokkan string,
ada baiknya penulis ulang kembali tentang pseudocode algoritma boyer-moore.
1. function BMSearch(
2. input n : integer, { panjang pattern }
3. input m : integer, { panjang teks }
4. input P : string, { string pattern }
5. input T :string { string teks }
6. ) boolean
7.
8. Deklarasi
9. i : integer { pointer dari teks }
10. j : integer { pointer dari pattern }
11. bmBCShift : integer { temp jumlah pergeseran bad-
character }
12. bmGSShift : integer { temp jumlah pergeseran good-
suffix }
13. shift : integer { temp pergeseran }
14. ketemu : boolean { temp ketemu }
15. bmBC : array[0..ASIZE] of integer { temp tabel bmBC }
16. bmGS : array[0..n-1] of integer { temp tabel bmGS }
17. procedure BadCharacter(input P : string, input n :
integer, output bmBC : array[0..n-1] of integer)
18. procedure GoodSuffix(input P : string, input n :
integer, output bmGS : array[0..n-1] of integer)
19.
20. Algoritma
21. BadCharacter(P, n, bmBC)
22. GoodSuffix(P, n, bmGS)
23. i := 0
24. ketemu := false
25. while (i <= m-n) do
26. j := n-1
27. while(j >= 0 and T[i+j] = P[j])
28. j := j-1
29. endwhile
30. if(j < 0) then
95
31. ketemu := true
32. i := i+ bmGS[0]
33. else
34. bmBCShift := bmBC[T[i+j]] - n + 1 + j
35. bmGSShift := bmGS[j]
36. shift := max(bmBCShift, bmGSShift)
37. i := i + shift
38. endif
39. endwhile
40. return ketemu
Langkah-langkah pencocokkan string menggunakan algoritma boyer-moore
sebagai berikut :
1. Baris ke-1 merupakan pemanggilan fungsi BMSearch
2. Baris ke-2 merupakan sebuah masukan dari panjang pattern (n), diketahui
n=8
3. Baris ke-3 merupakan sebuah masukan dari panjang teks (m), diketahui m=24
4. Baris ke-4 merupakan sebuah masukan dari pattern (P), diketahui
P=GCAGAGAG. Isi dari pattern (P) ini yang akan dicari disebuah teks(T)
5. Baris ke-5 merupakan sebuah masukan dari teks (T), diketahui
T=GCATCGCAGAGAGTATACAGTACG
6. Baris ke-6 menandakan bahwa fungsi BMSearch ini akan menghasilkan nilai
boolean, true atau false. Jika true berarti proses pencocokkan string ketemu,
dan jika false proses pencocokkan string tidak ketemu
7. Baris ke-8 merupakan sebuah komentar berisi Deklarasi
8. Baris ke-9, dideklarasikan pointer teks (i) dengan tipedata integer
9. Baris ke-10, dideklarasikan pointer pattern (j) dengan tipedata integer
10. Baris ke-11, dideklarasikan temp jumlah pergeseran bad-character
(bmBCShift) dengan tipedata integer
11. Baris ke-12, dideklarasikan temp jumlah pergeseran good-suffix (bmGSShift)
dengan tipedata integer
12. Baris ke-13, dideklarasikan temp pergeseran (shift) dengan tipedata integer
13. Baris ke-14, dideklarasikan ketemu dengan tipedata boolean
96
14. Baris ke-15, dideklarasikan temp tabel bmBC (bmBC) dengan tipedata array
integer, dengan lebar array sama dengan 256, mengikuti kode ASCII
(American Standard Code for Information Interchange)
15. Baris ke-16, dideklarasikan temp tabel bmGS (bmGS) dengan tipedata array
integer, dengan lebar array sama dengan panjang pattern (n)
16. Baris ke-17, dideklarasikan prosedur BadCharacter dengan masukan pattern
(P), panjang pattern (n) dan keluaran akan disimpan di variabel bmBC
17. Baris ke-18, dideklarasikan prosedur GoodSuffix dengan masukan pattern (P),
panjang pattern (n) dan keluaran akan disimpan di variabel bmGS
18. Baris ke-20 merupakan sebuah komentar yang berisi Algoritma yang
menandakan akan dimulainya algoritma ini
19. Baris ke-21 merupakan pre-processing terhadap algoritma boyer-moore, yang
akan menjalankan prosedur BadCharacter, prosesnya sudah dipaparkan dan
nilai bmBC seperti Tabel 4.2
20. Baris ke-22 merupakan pre-processing terhadap algoritma boyer-moore, yang
akan menjalankan prosedur GoodSuffix, prosesnya sudah dipaparkan dan nilai
bmGS seperti Tabel 4.4
21. Baris ke-23, inisialisasikan nilai i=0
22. Baris ke-24, inisialisasikan nilai ketemu=false
23. Baris ke-25 merupakan kondisi while-do, proses pengulangan while-do akan
berakhir jika kondisi dalam while-do tidak terpenuhi lagi. Nilai awal
perulangan while(i<=m-n) adalah while(0<=24-8) atau while(0<=16)
1) Posisi i=0
a. Baris ke-26, set nilai j:=n-1, j=8-1, nilai j=7
b. Baris ke-27, periksa kondisi while(j>=0 and T[i+j]=P[j])
a) while(7>=0 and T[0+7]=P[7]) atau while(7>=0 and „A‟=‟G‟)
hasil kondisi false, nilai j=7
c. Baris ke-30, periksa kondisi if(j<0) atau if(7<0) hasil kondisi false
d. Baris ke-34, set nilai bmBCShift:=bmBC[T[i+j]]-n+1+j,
bmBCShift=bmBC[T[0+7]]-8+1+7], bmBCShift=bmBC[T[7]]-0,
nilai bmBCShift=1
97
e. Baris ke-35, set nilai bmGSShift:=bmGS[j], bmGSShift=bmGS[7],
nilai bmGSShift=1
f. Baris ke-36, set nilai shift:=max(bmBCShift, bmGSShift),
shift=max(1,1), nilai shift=1
g. Baris ke-37, set nilai i=i+shift, i=0+1, nilai i=1
2) Posisi i=1
a. Baris ke-26, set nilai j:=n-1, j=8-1, nilai j=7
b. Baris ke-27, periksa kondisi while(j>=0 and T[i+j]=P[j])
a) while(7>=0 and T[1+7]=P[7]) atau while(7>=0 and „G‟=‟G‟)
hasil kondisi true. Baris ke-28, set nilai j:=j-1, j=7-1, nilai j=6
b) while(6>=0 and T[1+6]=P[6]) atau while(6>=0 and „A‟=‟A‟)
hasil kondisi true. Baris ke-28, set nilai j:=j-1, j=6-1, nilai j=5
c) while(5>=0 and T[1+5]=P[5]) atau while(5>=0 and „C‟=‟G‟)
hasil kondisi false, nilai j=5
c. Baris ke-30, periksa kondisi if(j<0) atau if(5<0) hasil kondisi false
d. Baris ke-34, set nilai bmBCShift:=bmBC[T[i+j]]-n+1+j,
bmBCShift=bmBC[T[1+5]]-8+1+5], bmBCShift=bmBC[T[6]]-2,
nilai bmBCShift=4
e. Baris ke-35, set nilai bmGSShift:=bmGS[j], bmGSShift=bmGS[5],
nilai bmGSShift=4
f. Baris ke-36, set nilai shift:=max(bmBCShift, bmGSShift),
shift=max(4,4), nilai shift=4
g. Baris ke-37, set nilai i=i+shift, i=1+4, nilai i=5
3) Posisi i=5
a. Baris ke-26, set nilai j:=n-1, j=8-1, nilai j=7
b. Baris ke-27, periksa kondisi while(j>=0 and T[i+j]=P[j])
a) while(7>=0 and T[5+7]=P[7]) atau while(7>=0 and „G‟=‟G‟)
hasil kondisi true. Baris ke-28, set nilai j:=j-1, j=7-1, nilai j=6
b) while(6>=0 and T[5+6]=P[6]) atau while(6>=0 and „A‟=‟A‟)
hasil kondisi true. Baris ke-28, set nilai j:=j-1, j=6-1, nilai j=5
98
c) while(5>=0 and T[5+5]=P[5]) atau while(5>=0 and „G‟=‟G‟)
hasil kondisi true. Baris ke-28, set nilai j:=j-1, j=5-1, nilai j=4
d) while(4>=0 and T[5+4]=P[4]) atau while(4>=0 and „A‟=‟A‟)
hasil kondisi true. Baris ke-28, set nilai j:=j-1, j=4-1, nilai j=3
e) while(3>=0 and T[5+3]=P[3]) atau while(3>=0 and „G‟=‟G‟)
hasil kondisi true. Baris ke-28, set nilai j:=j-1, j=3-1, nilai j=2
f) while(2>=0 and T[5+2]=P[2]) atau while(2>=0 and „A‟=‟A‟)
hasil kondisi true. Baris ke-28, set nilai j:=j-1, j=2-1, nilai j=1
g) while(1>=0 and T[5+1]=P[1]) atau while(1>=0 and „C‟=‟C‟)
hasil kondisi true. Baris ke-28, set nilai j:=j-1, j=1-1, nilai j=0
h) while(0>=0 and T[5+0]=P[0]) atau while(0>=0 and „G‟=‟G‟)
hasil kondisi true. Baris ke-28, set nilai j:=j-1, j=0-1, nilai j=-1
i) while(-1>=0 and T[5+(-1)]=P[-1]) atau while(4>=0 and „C‟=‟0‟)
hasil kondisi false, nilai j=-1
c. Baris ke-30, periksa kondisi if(j<0) atau if(5<0) hasil kondisi true
d. Baris ke-31, set nilai ketemu:=true
e. Baris ke-32, set nilai i=i+bmGS[0], i=5+7, nilai i=12
4) Posisi i=12
a. Baris ke-26, set nilai j:=n-1, j=8-1, nilai j=7
b. Baris ke-27, periksa kondisi while(j>=0 and T[i+j]=P[j])
a) while(7>=0 and T[12+7]=P[7]) atau while(7>=0 and „G‟=‟G‟)
hasil kondisi true. Baris ke-28, set nilai j:=j-1, j=7-1, nilai j=6
b) while(6>=0 and T[12+6]=P[6]) atau while(6>=0 and „A‟=‟A‟)
hasil kondisi true. Baris ke-28, set nilai j:=j-1, j=6-1, nilai j=5
c) while(5>=0 and T[12+5]=P[5]) atau while(5>=0 and „C‟=‟G‟)
hasil kondisi false, nilai j=5
c. Baris ke-30, periksa kondisi if(j<0) atau if(5<0) hasil kondisi false
d. Baris ke-34, set nilai bmBCShift:=bmBC[T[i+j]]-n+1+j,
bmBCShift=bmBC[T[12+5]]-8+1+5], bmBCShift=bmBC[T[17]]-2,
nilai bmBCShift=4
99
e. Baris ke-35, set nilai bmGSShift:=bmGS[j], bmGSShift=bmGS[5],
nilai bmGSShift=4
f. Baris ke-36, set nilai shift:=max(bmBCShift, bmGSShift),
shift=max(4,4), nilai shift=4
g. Baris ke-37, set nilai i=i+shift, i=12+4, nilai i=16
5) Posisi i=16
a. Baris ke-26, set nilai j:=n-1, j=8-1, nilai j=7
b. Baris ke-27, periksa kondisi while(j>=0 and T[i+j]=P[j])
a) while(7>=0 and T[16+7]=P[7]) atau while(7>=0 and „G‟=‟G‟)
hasil kondisi true. Baris ke-28, set nilai j:=j-1, j=7-1, nilai j=6
b) while(6>=0 and T[16+6]=P[6]) atau while(6>=0 and „A‟=‟G‟)
hasil kondisi false, nilai j=6
c. Baris ke-30, periksa kondisi if(j<0) atau if(5<0) hasil kondisi false
d. Baris ke-34, set nilai bmBCShift:=bmBC[T[i+j]]-n+1+j,
bmBCShift=bmBC[T[16+6]]-8+1+6], bmBCShift=bmBC[T[22]]-1,
nilai bmBCShift=5
e. Baris ke-35, set nilai bmGSShift:=bmGS[j], bmGSShift=bmGS[6],
nilai bmGSShift=7
f. Baris ke-36, set nilai shift:=max(bmBCShift, bmGSShift),
shift=max(5,7), nilai shift=7
g. Baris ke-37, set nilai i=i+shift, i=16+7, nilai i=23
6) Posisi i=23
Keluar dari kondisi while-do, karena tidak sesuai dengan kondisi while(i<=16)
24. Baris ke-40, hasil dari pencocokkan string ketemu dimana nilai ketemu=true
pada percobaan ke-3) posisi i=5
Tabel nilai untuk pergeseran bad-character dan good-suffix dapat dihitung
dengan komplekitas waktu dan ruang sebesar O(n + ) dengan adalah sebesar
ruang alphabet. Sedangkan fase pencarian algoritma boyer-moore membutuhkan
waktu sebesar O(mn). Pada kasus terburuk, algoritma boyer-moore akan
100
melakukan 3n pencocokkan karakter, namun pada performa terbaiknya algoritma
ini hanya akan melakukan O(m/n) pencocokkan.
4.1.2.4 Kesimpulan Analisis Algoritma String Matching
Tabel 4.5 Perbandingan algoritma string matching
Uji perbandingan Brute Force Knuth-Morris-Pratt Boyer-Moore
Mulai pencocokkan string Dari kiri Dari kiri Dari kanan
Fungsi/prosedur 0 1 prosedur 3 prosedur
Proses waktu 0 (tidak ada
proses) (n) (n + ||)
Total waktu ((m-n+1)n) ((m-n+1)+n)
Best (m-n+1)/n),
Worst ((m-n+1)n + ||)
Keterangan :
= Notasi Omega-Besar
= Notasi Theta-Besar
|| = Ruang Alphabet
n = Panjang Pattern
m = Panjang Teks
4.1.3 Analisis Kebutuhan Sistem
Penelitian dan pengembangan aplikasi pencarian berkas di komputer ini,
pengembangan sistem dilakukan dengan spesifikasi software dan hardware
sebagai berikut (software dan hardware yang penulis gunakan ):
101
1. Software
Software yang digunakan meliputi :
a. Sistem operasi Windows XP Service Pack 2
b. Microsoft Visual Studio 2005 dengan bahasa pemograman C#
sebagai alat bantu dalam pembuatan aplikasi
2. Hardware
Adapun hardware yang digunakan sebagai berikut :
a. Komputer AMD Athlon 64 X2 dengan prosesor 3800+
b. Memori 1024 MB
c. Hardisk 80 GB
d. VGA ATI Radeon X1050, 128 MB
4.2 Fase Perancangan
4.2.1 Perancangan Proses
4.2.1.1 Perancangan Proses Aplikasi
Analisis pembuatan aplikasi pencarian berkas di komputer ini dapat
digambarkan secara konseptual sebagai berikut :
Input Kata
Pilih Drive
Pilih Algoritma
String MatchingOutput Hasil
PencarianRekursi (Drive)
Pencarian berkas di komputer
Gambar 4.1 Pencarian berkas di komputer
102
4.2.1.2 Rekursi
Rekursi berfungsi sebagai alat bantu pemecah masalah yang penting dalam
ilmu komputer dan matematik, serta banyak dikembangkan untuk algoritma
searching dan sorting pada struktur list dan tree (Agastani : 2004).
Kebanyakan orang secara alamiah tidak berfikir secara rekursi. Untuk
contoh ketika diminta mendefinisikan fungsi pangkat xn, dimana x bilangan real
dan n integer non-negatif, tanggapan tipikal akan menggunakan perkalian
berulang dari x.
Xn = X * X * X … * X * X
n kali
Gambar 4.2 Rekursi n kali
Rekursi terjadi ketika memecahkan masalah dengan mempartisi ke sub-
masalah yang lebih kecil yang dipecahkan dengan algoritma yang sama. Proses
partisi berakhir ketika mencapai sub-masalah lebih sederhana yang bisa
dipecahkan.
Untuk mencari nama berkas tentunya kita harus membacanya satu persatu
nama berkas yang ada di tempat atau direktori yang kita inginkan. Untuk
permasalahan ini, tool yang digunakan telah mempunyai solusinya, yakni dengan
menggunakan recursively search directories yang telah disediakan oleh .NET
Framework (Hilyard, 2008:459).
Ada 2 (dua) tingkat rekursi yang digunakan pada aplikasi ini, yaitu rekursi
untuk mendapatkan nama direktori
foreach(string strDirs in Directory.GetDirectories(namaDirektori))
103
dan rekursi untuk mendapatkan nama berkas
foreach(string strFiles in Directory.GetFiles(namaBerkas))
4.2.1.3 String Matching
Pencarian string yang juga bisa disebut pencocokan string (string matching)
merupakan algoritma untuk melakukan semua kemunculan string pendek
pattern[0..n-1] yang disebut pattern di string yang lebih panjang teks[1..m-1]
yang bisa disebut teks (Charras : 1997).
Pada pembuatan aplikasi ini, penulis menggunakan algoritma string
matching untuk membandingkan string yang berada pada input kata dengan nama
berkas (file) dan direktori (folder) yang berada di drive sebuah komputer.
Aplikasi ini menggunakan 3 (tiga) buah algoritma dari algoritma string
matching, yaitu algoritma brute force, algoritma knuth-morris-pratt dan algoritma
boyer-moore.
4.2.1.4 Algoritma Pencarian Berkas di Komputer
1. Pseudocode
Penulisan pseudocode dari program aplikasi pencarian berkas dikomputer ini
adalah sebagai berikut :
1) Input kata, Pilih sensitifitas kata, Pilih drive, dan pilih algoritma
2) Jika input kata = kosong maka hasil pencarian akan kosong
3) Rekursi drive
4) Pemilihan algoritma
5) Jika sensitifitas kata tidak dipilih. Kata, nama berkas dan nama direktori di
setting menjadi hurup kecil
104
6) Bandingkan input kata dengan nama berkas atau nama direktori dengan
algoritma yang dipilih
7) Nama berkas atau nama direktori ketemu, output nama berkas atau nama
direktori
8) Akhir rekursi
9) Akhir algoritma
2. Flowchart
Flowchart dari algoritma di atas sebagai berikut :
START
Input Kata
Pilih Drive
Pilih Algoritma
Pilih Sensitifitas
Kata = Kosong
Rekursi pada Drive
String Matching
FINISH
Ya
Tidak
hentikanYa
Tidak
Gambar 4.3 Flowchart algoritma pencarian berkas di komputer
105
Ya
String Matching
Switch
Algoritma
Case
Algoritma =
Brute-Foce
Case
Algoritma =
Knuth-Morris-Pratt
Case
Algoritma =
Boyer-Moore
Kata <= File/
FolderHasil
Return
Ya
Ya
Tidak
Tidak
Sensitifitas
Kata ToLower
File/Folder ToLower
Kata <= File/
FolderHasil
Kata <= File/
FolderHasil
Ya
Ya
Ya
Ya
Tidak
Gambar 4.4 Flowchart bagian string matching
4.2.2 Perancangan Antarmuka
1. Form Splash Screen
Form splash screen adalah menu pembuka dari aplikasi yang dibuat.
Menu ini berbentuk animasi sederhana dengan berupa gambar dan tulisan
106
yang tampil pada desktop (layar) komputer dalam waktu beberapa mili-
detik. Rancangan form splash screen adalah seperti gambar 4.5 berikut :
Logo Splash Screen
Keterangan
Gambar 4.5 Rancangan form splash screen
Berikut ini rancangan form digambarkan dalam STD :
Form Splash Screen Form Menu UtamaTimer
Gambar 4.6 Rancangan STD form splash screen
2. Form Menu Utama
Form menu utama adalah menu utama dari aplikasi ini. Penerapan sistem
aplikasi pencarian berkas di komputer akan diterapkan pada form ini.
Rancangan form ini seperti tampak pada gambar 4.7 berikut ini :
107
Pilih AlgoritmaPilih Logikal
Drive
Input Kata
Tombol Cari
Informasi Hasil
Pencarian
Keterangan
Hasil Pencarian
Pilih Sensitifitas
Tombol
Bantuan
Tombol Info
Tombol
Pembuat
Tombol
Keluar
Tombol
Hentikan
Gambar 4.7 Rancangan form menu utama
Rancangan form menu utama dalam bentuk STD berikut ini :
Form Menu
Utama
Pencarian
Berkas
HentikanHentikan klik
BantuanBantuan klik Form BantuanForm klik
InfoInfo klik Form InfoForm klik
PembuatPembuat klik Form PembuatForm klik
KeluarKeluar klik
CariCari klik
Gambar 4.8 Rancangan STD form menu utama
108
3. Form Bantuan
Form bantuan mempunyai sebagian menu bantuan bagi pemakai yang
belum mengerti atau memahami cara menggunakan program SOE Desktop
Search.
Form bantuan ini dilengkapi dengan 6 (enam) tombol yang mempunyai
fungsi sebagai berikut :
a. Tombol Hide : mempunyai fungsi untuk menyembunyikan tab content
dan tab search.
b. Tombol Back : mempunyai fungsi untuk menampilkan kembali
halaman yang telah dibuka sebelumnya.
c. Tombol Forward : mempunyai fungsi untuk menampilkan kembali
halaman yang telah dibuka sesudahnya.
d. Tombol Home : mempunyai fungsi untuk menampilkan halaman ke
indek awal.
e. Tombol Print : mempunyai fungsi untuk mencetak halaman bantuan
yang ditampilkan.
f. Tombol Options : mempunyai beberapa fungsi
1) Menampilkan dan menyembunyikan tab
2) Menampilkan halaman yang sebelumnya telah dibuka (back)
3) Menampilkan halaman yang sesudahnya telah dibuka (forward)
4) Kembali ke halaman utama (home)
5) Menghentikan proses (stop)
6) Me-refresh program bantuan (refresh)
109
7) Menampilkan internet options
g. Tombol Contents : mempunyai fungsi untuk menampilkan topik
bantuan
h. Tombol Search : mempunyai fungsi untuk mencari topik berdasarkan
kata yang dicari.
Untuk memperjelas rancangan form bantuan dapat dilihat pada gambar 4.9
berikut ini.
Hide Back Forward Home Print Options
Contents Search
Gambar 4.9 Rancangan form bantuan
STD dari rancangan form bantuan sebagai berikut :
Form Bantuan Form UtamaTutup klik
Gambar 4.10 Rancangan STD form bantuan
110
4. Form Info
Form Info berfungsi untuk memberikan informasi software yang dibuat.
Rancangan form tersebut seperti gambar 4.11 berikut :
Gambar
Label Judul Aplikasi
Tombol OK
Gambar 4.11 Rancangan form info
STD dari rancangan form info sebagai berikut :
Form Info Form UtamaTutup klik
Gambar 4.12 Rancangan STD form info
5. Form Pembuat
Form pembuat berfungsi untuk memberikan informasi pembuat software.
Rancangan form tersebut sebagai berikut :
Gambar
Label Judul Pembuat
Tombol OK
Gambar 4.13 Rancangan form pembuat
111
STD dari rancangan form pembuat sebagai berikut :
Form Pembuat Form UtamaTutup klik
Gambar 4.14 Rancangan STD form pembuat
4.3 Fase Konstruksi
Dengan algoritma yang telah dipaparkan dan aturan-aturan yang telah
dibuat sebelumnya, maka kita akan mencoba untuk menggunakan input kata
“pdf”, sesitifitas tidak dipilih, drive yang dipilih adalah C:\ dan algoritma yang
dipilih adalah brute-force, seperti pada gambar 4.15 berikut ini :
Rekursi drive C:\
algoritma = brute-force
pdf <= nama file,
pdf <= nama direktori
C:\Documents and
Settings\soevar\My
Documents\jquery.pdf
pdf.tolower(),
nama berkas.tolower()
nama direktori.tolower()
Gambar 4.15 Proses pencarian kata
112
Proses yang terjadi dalam aplikasi pencarian berkas terjadi pada gambar
4.16 berikut ini :
Input Kata
Pilih Drive
Pilih Algoritma
Pilih Sensitifitas
String MatchingOutput Hasil
PencarianRekursi (Drive)
Pencarian berkas di komputer
Gambar 4.16 Proses pada pencarian berkas
Pada implementasi program gambar 4.16, menjelaskan drive C:\ akan
direkursi sampai akhir drive, di dalam proses rekursi itu akan dibandingkan input
kata dengan nama berkas dan nama direktori menggunakan algoritma brute-force,
apabila dalam proses pembandingan tersebut kata input sama dengan sebagian
nama berkas atau nama direktori maka hasil pencarian akan memberikan output
pada posisi path dari nama berkas atau nama direktori ini.
4.4 Fase Pelaksanaan
Pada tahap ini dilakukan pengujian terhadap sistem dan melakukan terhadap
sistem meliputi spesifikasi hardware dan software yang digunakan dan
pengenalan tampilan. Pada tahap pengujian aplikasi pencarian berkas di komputer,
penulis menggunakan pengujian white-box yaitu sebuah pengujian perangkat
lunak dari jalannya program.
4.4.1 Pengujian Sistem Aplikasi Pencarian Berkas
Berikut ini adalah pengujian dengan menggunakan pengujian white-box
pada sistem aplikasi pencarian berkas di komputer. Dimulai dari tahap awal.
113
Setelah ikon di klik maka akan muncul form splash screen. Setelah itu akan
masuk ke dalam form menu utama. Pengujian berikut kita akan memasukkan kata
pada form menu utama pada layar input (TextBox). Aplikasi masih dalam keadaan
default, pemilihan algoritma tidak dirubah dan pemilihan logikal drive tidak
dirubah. Seperti gambar 4.17 berikut ini.
Gambar 4.17 Tampilan proses pencarian diterima
Jika pada layar input (TextBox) kosong atau null, maka aplikasi ini tidak
akan diproses dan pada layar input (TextBox) akan berwarna merah. Seperti
gambar 4.18 berikut ini.
114
Gambar 4.18 Tampilan proses pencarian tidak diterima
4.4.2 Spesifikasi Hardware dan Software
Pengenalan suatu sistem terhadap spesifikasi software dan hardware yang
digunakan. Seperti berikut ini :
1. Perangkat keras (hardware)
Perangkat keras untuk menjalankan aplikasi ini adalah satu unit
komputer dengan konfigurasi sebagai berikut :
a. Prosesor setara 600 Mhz ke atas
b. Memori minimal 64 MB, tetapi direkomendasikan menggunakan
memori minimal 128 MB
c. Monitor dengan resolusi minimal 800x600
d. Keyboard dan mouse
e. VGA 32 MB
f. Soundcard
115
2. Perangkat lunak (software)
Perangkat lunak untuk menjalankan sistem ini adalah sebagai berikut :
a. Sistem operasi Windows 2000/XP/Vista
b. Microsoft .NET Framework 2.0 atau Mono Framework 2.0.1
4.4.3 Pengenalan Tampilan
Pada tahap ini membahas perancangan form dan pengujian sistem. Modul-
modul fungsi program (kode program dapat dilihat di lampiran). Pada program
aplikasi pencarian berkas di komputer ini membuat 5 (lima) form (interface) yaitu
form splash screen, form menu utama, form bantuan, form info, form pembuat.
Tampilan form splash screen dari aplikasi ini seperti tampak pada gambar 4.19
berikut :
Gambar 4.19 Tampilan form splash screen
Pada form splash screen tidak terdapat tombol apapun. Form ini berdurasi
beberapa milidetik kemudian masuk ke dalam form menu utama. Form ini
bertujuan menunjukkan indentitas program.
116
Tampilan form menu utama menggunakan .NET Framework seperti tampak
pada gambar 4.20 berikut :
Gambar 4.20 Tampilan form menu utama dengan .NET
Tampilan form menu utama menggunakan Mono Framework seperti tampak
pada gambar 4.21 berikut :
Gambar 4.21 Tampilan form menu utama dengan Mono
117
Pada form menu utama ini ada 5 (lima) buah tombol. Keterangan tombol
tersebut seperti berikut ini :
1.
Tombol ini berfungsi untuk memulai pencarian kata/file pada berkas sebuah
komputer.
2.
Tombol ini berfungsi untuk memanggil form bantuan.
3.
Tombol ini berfungsi untuk memanggil form info yang akan
menampilkan keterangan aplikasi.
4.
Tombol ini berfungsi untuk memanggil form pembuat yang akan menampilkan
keterangan si pembuat aplikasi.
5.
Tombol ini mempunyai fungsi untuk keluar dari aplikasi.
6.
Tombol ini berfungsi untuk menghentikan proses pencarian.
Pada form menu utama ini ada 2 (dua) layar pemilihan (ComboBox), 1 (satu)
layar pengecekan (CheckBox) dan 1 (satu) layar input (TextBox). Keterangan dari
fungsi-fungsi itu sebagai berikut :
118
Tabel 4.6 Tabel fungsi combobox, checkbox dan textbox pada menu utama
Gambar Nama Fungsi
Pilih Algoritma
Untuk memilih algoritma
yang akan dipakai untuk
mecari berkas di sebuah
komputer. Terdapat 3 buah
algoritma yaitu brute force,
knuth-morris-pratt dan
boyer-moore.
Pilih Logikal Drive
Untuk memilih drive mana
yang akan dijadikan tujuan
pencarian dari kata yang
hendak dicari. Jumlah
logikal drive tegantung dari
banyaknya drive pada
sebuah komputer.
Masukkan Kata
Untuk memasukkan kata
yang hendak dicari.
Cek sensitifitas
Untuk mengecek sensitifitas
input-an kata terhadap nama
berkas atau nama direktori
Tampilan dari form bantuan seperti tampak pada gambar 4.22 berikut :
119
Gambar 4.22 Tampilan form bantuan
Tampilan dari form info seperti tampak pada gambar 4.23 berikut :
Gambar 4.23 Tampilan form info
120
Tampilan dari form pembuat seperti tampak pada gambar 4.24 berikut :
Gambar 4.24 Tampilan form pembuat
4.4.4 Pengujian Algoritma String Matching
Pada bahasan ini penulis akan membandingkan efektifitas dan efisensi dari
algoritma brute force, algoritma knuth-morris-pratt dan algoritma boyer-moore.
Sebelum penulis membandingkan dari algoritma tersebut, ada baiknya penulis
memberikan informasi/keterangan tentang komputer yang dijadikan bahan uji
coba.
Pada pengujian tersebut penulis menggunakan perangkat keras dan
perangkat lunak seperti tampak pada gambar 4.25 berikut ini :
121
Gambar 4.25 Informasi perangkat keras dan perangkat lunak untuk uji coba
Dan untuk drive uji cobanya penulis menggunakan drive D:\ dari komputer
penulis, keterangan drive D:\ seperti tampak pada gambar 4.26 berikut ini.
Gambar 4.26 Keterangan drive untuk uji coba
122
Dan untuk kata yang ingin penulis uji cobakan adalah kata “visual”. Untuk
mendapatkan hasil yang maksimal maka untuk 1 (satu) aplikasi yang berjalan
penulis menggunakan 1 (satu) algoritma dari algoritma string matching tersebut.
Pada saat pengujian terhadap algoritma string matching tersebut, proses yang
sedang berjalan (running process) pada komputer penulis seperti tampak pada
gambar 4.27 berikut.
124
Hasil uji coba pencarian berkas di komputer dengan menggunakan kata
kunci “visual” pada drive D:\, yaitu :
1. Algoritma brute force
Sangat cocok untuk mencari nama berkas dan nama direktori yang
pendek, tidak efisien apabila nama berkas dan nama direktori terlalu
panjang. Dengan algoritma brute force hasil pencarian akan
mendapatkan hasil yang utuh.
Gambar 4.28 Penggunaan memori untuk algoritma brute force
Gambar 4.29 Pemakaian CPU untuk algoritma brute force
125
Gambar 4.30 Hasil pencarian dengan algoritma brute force
2. Algoritma knuth-morris-pratt
Lebih efisien dari algoritma brute force, bila dengan algoritma brute
force waktu pencariannya 46,40588 detik sedangkan untuk algoritma
knuth-morris-pratt waktu pencariannya 63,71812 detik.
Gambar 4.31 Penggunaan memori untuk algoritma knuth-morris-pratt
126
Gambar 4.32 Pemakaian CPU untuk algoritma knuth-morris-pratt
Gambar 4.33 Hasil uji coba dengan algoritma knuth-morris-pratt
3. Algoritma boyer-moore
Sangat cocok untuk mencari nama berkas dan nama direktori yang
panjang, bila dibangdingkan dengan algoritma brute force dan algoritma
knuth-morris-pratt, algoritma boyer-moore medapatkan waktu yang
relatif singkat hanya 45,53125 detik. Kelemahan terbesar dari algoritma
127
boyer-moore adalah tidak dapat menemukan nama berkas dan nama
direktori apabila penamaannya tidak menggunakan penamaan ASCII.
Gambar 4.34 Penggunaan memori untuk algoritma boyer-moore
Gambar 4.35 Pemakaian CPU untuk algoritma boyer-moore
Gambar 4.36 Hasil uji coba dengan algoritma boyer-moore
128
Tabel 4.7 berikut ini merupakan rangkuman hasil uji coba dari aplikasi
pencarian berkas di komputer dengan menggunakan algoritma string matching,
dengan input-an kata yang dicari adalah “visual” pada drive D:\.
Tabel 4.7 Hasil uji coba algoritma string matching
Keterangan Brute Force Knuth-Morris-Pratt Boyer-Moore
Kata visual visual Visual
Folder ketemu 18 folder 18 folder 18 folder
File ketemu 54 file 54 file 54 file
Waktu (detik) 63.71812 46,40588 45,53125
Kategori algoritma Sederhana Sedang Rumit
Penggunaan
memori (byte)
824.000 1.332.000 1.724.000
129
BAB V
PENUTUP
5 PENUTUP
5.1 Kesimpulan
Dalam bab penutup ini, kesimpulan yang dapat diperoleh secara
keseluruhan materi pembahansan pada bab-bab sebelumnya yaitu :
1. Permasalahan string matching adalah masalah menemukan string
pattern yang cocok pada sebuah teks.
2. Algoritma brute force terbukti merupakan algoritma yang paling
sederhana ditandai dengan tidak adanya preprocessing. Kurang efisien
bila mencari pattern di teks yang panjang namun dari segi efektifitas
dari hasil yang didapatkan algoritma brute force dapat menemukan hasil
pencarian yang sangat jelas.
3. Algoritma knuth-morris-pratt merupakan algoritma yang berkategori
sedang ditandai dengan adanya preprocessing. Lebih efisien dalam hal
waktu pemrosesan dibandingkan dengan algoritma brute force disertai
dengan efektifitas dari hasil yang didapatkan.
4. Algoritma boyer-moore merupakan algoritma yang berkategori rumit
ditandai dengan 3 buah prosedur di dalam preprocessing. Sangat efisien
jika diimplementasikan pada teks yang panjang namun algoritma boyer-
moore kurang efektif bila mencari teks selain teks berjenis ASCII.
130
5.2 Saran
Saran-saran yang dapat penulis sampaikan sehubungan dengan materi yang
telah disampaikan oleh penulis sebagai berikut :
1. Sistem dapat dikembangkan lebih lanjut tidak hanya untuk algoritma
brute force, algoritma knuth-morris-pratt dan algoritma boyer-moyer
saja. Dengan algoritma string matching yang lebih advance seperti
algoritma smith, diharapkan efisensi hasil pencarian dapat
disempurnakan dan waktu yang diperoleh dapat diminimalisir.
2. Apabila menggunakan Framework Mono waktu yang diperoleh dapat
diminimalisir dengan baik namun ada beberapa fasilitas yang tidak bisa
dijalankan.
3. Bisa diimplementasikan pada beberapa sistem operasi.
131
DAFTAR PUSTAKA
Daftar Pustaka
Agastani, Tahar. 2004. Stuktur Data (Berorientasi Objek dengan C++).
Charras, Chistian., et al. 1997. Handbook of Exact String-Matching Algorithms,
http://www-igm.univ-mlv.fr/%7Elecroq/string/string.pdf,
15 Juli 2008, pk. 22.10 WIB.
Handayani, Dewi. 2001. Sistem Berkas. Yogyakarta: J&J Learning.
Hartono, Jogiyanto. 2000. Pengenalan Komputer. Yogyakarta: Andi.
Hilyard, Jay and Theilhet, Stephen. 2008. C# 3.0 Cookbook. Sebastopol: O’Reilly
Media.
Kadir, Abdul, et al. 2005. Pengenalan Teknologi Informasi. Yogyakarta: ANDI.
Kendall & Kendall. 2003. Analisis dan Perancangan Sistem. Jakarta: PT.
Prenhallindo.
Knuth, Donald E., et al. 1977. Fast Pattern Matching in Strings. SIAM Journal on
Computing 6(1).
Kusumo, Ario Suryo. 2007. Buku Latihan Pemograman Visual Basic 2005.
Jakarta: Elek Media Komputindo.
MDGR (Masyarakat Digital Gotong Royong). 2005. Pengantar Sistem Operasi
Komputer : Plus Ilustrasi Kernel Linux.
http://bebas.vlsm.org/v06/Kuliah/SistemOperasi/BUKU/,
15 Juli 2008, pk 22.00 WIB.
Munir, Renaldi. 2001. Algoritma & Pemograman Dalam Bahasa Pascal Dan C
Buku 1. Bandung: Informatika.
132
Munir, Renaldi. 2002. Algoritma & Pemograman Dalam Bahasa Pascal Dan C
Buku 2. Bandung: Informatika.
Munir, Renaldi. 2004. Algoritma Pencarian String (String Matching). Bandung:
Institut Teknologi Bandung.
Purwanindita, Alin Kurniawan, et al. String Matching Algorithm. Bandung:
Sekolah Tinggi Teknologi Telkom.
Pressman, Roger S. 2002. Rekayasa Perangkat Lunak: pendekatan praktisi (Buku
I). Yogyakarta: ANDI.
Boyer, Robert S., et al. 1977. A Fast String Searching Algorithm.
Communications of the ACM 20.
Sedgewick, Robert. 1984. Algorithms. USA: Addison-Wesley.
133
Lampiran Source Code
frmUtama.cs
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Text;
using System.Windows.Forms;
namespace ProjectStringMatching
{
public partial class frmUtama : Form
{
frmSplashScreen frmSplashScreenBuka = new frmSplashScreen();
private ListViewItem lviHasil;
private ListViewItem.ListViewSubItem lvsiHasil;
private int intFileKetemu;
private int intFolderKetemu;
private int intJumlahHasil;
private bool boolHentikan;
public frmUtama()
{
InitializeComponent();
frmSplashScreenBuka.Show();
Application.DoEvents();
}
private void frmUtama_Activated(object sender, EventArgs e)
{
// Tutup form splash screen
frmSplashScreenBuka.Close();
}
private void frmUtama_Load(object sender, EventArgs e)
{
cbxLogicalDrive.Items.Clear();
foreach (string drv in Directory.GetLogicalDrives())
{
cbxLogicalDrive.Items.Add(drv);
}
// Biarkan si load mengisi yang pertama
cbxPilihAlgoritma.Text = "Knuth-Morris-Pratt"; // Sebagai Default
cbxLogicalDrive.Text = System.IO.Directory.GetCurrentDirectory();
tssLblOnScanning.Text = cbxLogicalDrive.Text;
// Tombol hentikan di non-aktifkan terlebih dahulu
btnHentikan.Enabled = false;
}
private void txtPattern_KeyPress(object sender, KeyPressEventArgs e)
{
if (e.KeyChar == 13)
{
// Langsung ke prosedur btnCari_Click abis tekan Enter
this.btnCari_Click(this.txtPattern.Text, e);
}
}
private void btnCari_Click(object sender, EventArgs e)
{
lvwHasil.Items.Clear();
if (txtPattern.Text.Length != 0)
{
// Inisialisasi untuk waktu
float waktuMulai;
134
float waktuAkhir;
float waktuNya;
// Update component
intFileKetemu = 0;
intFolderKetemu = 0;
SetVisibleIsiFrmUtama();
tssLblStatusProgram.Text = "Mencari... ";
SetInvisiblecmsOpen();
lvwHasil.DoubleClick -= new
System.EventHandler(this.lvwHasil_DoubleClick);
// Atur waktu sebelum pencarian
waktuMulai = waktuPencarian(DateTime.Now);
// status proses set menjadi true;
boolHentikan = false;
// Proses Mencarinya :D
DirSearch(cbxLogicalDrive.Text);
DirRecursiveSearch(cbxLogicalDrive.Text);
// Waktu akhir
waktuAkhir = waktuPencarian(DateTime.Now);
waktuNya = waktuAkhir - waktuMulai;
// Update componen
SetUnvisibleIsiFrmUtama();
tssLblOnScanning.Text = cbxLogicalDrive.Text;
tssLblStatusProgram.Text = "Siap... ";
// Update buat Informasi Hasil
lblHAlgoritma.Text = cbxPilihAlgoritma.Text;
lblHWaktu.Text = waktuNya.ToString() + " detik";
lblHFileKetemu.Text = intFileKetemu + " file";
lblHFolderKetemu.Text = intFolderKetemu + " folder";
// Berikan hak untuk langsung membuka file/folder
if ((intFileKetemu > 0) || (intFolderKetemu > 0))
{
SetVisiblecmsOpen();
this.lvwHasil.DoubleClick += new
System.EventHandler(this.lvwHasil_DoubleClick);
}
// Tampilin Informasi Kalau dah rapih :P
MessageBox.Show("Pencarian Selesai..." +
"\nMengunakan algoritma " + cbxPilihAlgoritma.Text
+
"\nWaktu Pencarian " + lblHWaktu.Text +
"\nKetemu " + lblHFileKetemu.Text +
"\nKetemu " + lblHFolderKetemu.Text
, "Informasi");
}
else
{
// Warnain txtPattern jadi merah
txtPattern.BackColor = Color.Red;
}
}
private void btnHentikan_Click(object sender, EventArgs e)
{
boolHentikan = true;
}
private void btnHelp_Click(object sender, EventArgs e)
{
// Buka file help dong :P
Help.ShowHelp(this, "help.chm", HelpNavigator.Topic, "index.html");
}
private void btnAbout_Click(object sender, EventArgs e)
{
// Buka form Info
135
frmTentang frmTentangBuka = new frmTentang();
frmTentangBuka.ShowDialog();
}
private void btnPembuat_Click(object sender, EventArgs e)
{
// Buka form si pembuat :D
frmPembuat frmPembuatBuka = new frmPembuat();
frmPembuatBuka.ShowDialog();
}
private void btnExit_Click(object sender, EventArgs e)
{
// Yah Zia keluar
Application.Exit();
}
private void cbxLogicalDrive_TextChanged(object sender, EventArgs e)
{
// Update otomatis untuk si tssLblOnScanning berada di stpStatus
tssLblOnScanning.Text = cbxLogicalDrive.Text;
}
private float waktuPencarian(DateTime dateTime)
{
// Prosedur buat ngedapetin waktu dalam milidetik
int intJam;
int intMenit;
int intDetik;
float floatMiliDetik;
float floatWaktu;
intJam = dateTime.Hour;
intMenit = dateTime.Minute;
intDetik = dateTime.Second;
floatMiliDetik = dateTime.Millisecond;
floatWaktu = (float)(intJam * 3600) + (intMenit * 60) + intDetik +
(floatMiliDetik / 1000);
return floatWaktu;
}
private void SetUnvisibleIsiFrmUtama()
{
// Jadikan semua komponen Aktif
this.Cursor = Cursors.Default;
cbxPilihAlgoritma.Enabled = true;
cbxLogicalDrive.Enabled = true;
txtPattern.Enabled = true;
cbxSensitif.Enabled = true;
btnCari.Enabled = true;
btnHelp.Enabled = true;
btnPembuat.Enabled = true;
btnAbout.Enabled = true;
btnExit.Enabled = true;
btnHentikan.Enabled = false;
}
private void SetVisibleIsiFrmUtama()
{
// Jadikan semua komponen tidak Aktif
cbxPilihAlgoritma.Enabled = false;
cbxLogicalDrive.Enabled = false;
txtPattern.Enabled = false;
txtPattern.BackColor = SystemColors.Window;
cbxSensitif.Enabled = false;
btnCari.Enabled = false;
btnHelp.Enabled = false;
btnAbout.Enabled = false;
btnPembuat.Enabled = false;
btnExit.Enabled = false;
btnHentikan.Enabled = true;
this.Cursor = Cursors.WaitCursor;
}
private void mnuOpen_Click(object sender, EventArgs e)
{
try
{
136
System.Diagnostics.Process.Start(this.lvwHasil.SelectedItems[0].Tag.ToString());
}
catch (System.Exception ex)
{
MessageBox.Show(ex.Message, "Peringatan..");
}
}
private void mnuOpenFolder_Click(object sender, EventArgs e)
{
try
{
OpenContainingFolder(this.lvwHasil.SelectedItems[0].Tag.ToString());
}
catch (System.Exception ex)
{
MessageBox.Show(ex.Message, "Peringatan..");
}
}
private void lvwHasil_DoubleClick(object sender, EventArgs e)
{
try
{
System.Diagnostics.Process.Start(this.lvwHasil.SelectedItems[0].Tag.ToString());
}
catch (System.Exception ex)
{
MessageBox.Show(ex.Message, "Peringatan..");
}
}
private void lvwHasil_ColumnClick(object sender, ColumnClickEventArgs e)
{
ListViewSorter sorter = new ListViewSorter();
lvwHasil.ListViewItemSorter = sorter;
if (!(lvwHasil.ListViewItemSorter is ListViewSorter))
{
return;
}
sorter = (ListViewSorter)lvwHasil.ListViewItemSorter;
if (sorter.LastSort == e.Column)
{
if (lvwHasil.Sorting == SortOrder.Ascending)
{
lvwHasil.Sorting = SortOrder.Descending;
}
else
{
lvwHasil.Sorting = SortOrder.Ascending;
}
}
else
{
lvwHasil.Sorting = SortOrder.Descending;
}
sorter.ByColumn = e.Column;
lvwHasil.Sort();
}
private void SetVisiblecmsOpen()
{
mnuOpen.Visible = true;
mnuOpenFolder.Visible = true;
}
private void SetInvisiblecmsOpen()
{
mnuOpen.Visible = false;
137
mnuOpenFolder.Visible = false;
}
private void OpenContainingFolder(string fullPath)
{
string folder = "";
bool ketemu = false;
int i = fullPath.Length - 1;
int j = 0;
do
{
if (fullPath[i] == '\\')
{
ketemu = true;
}
else
{
i--;
}
} while (!ketemu);
for (j = 0; j <= i; j++)
{
folder = folder + fullPath[j];
}
try
{
System.Diagnostics.Process.Start(folder);
}
catch (System.Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private string GetDirectoryName(string dirPath)
{
int i = 1;
bool ketemu = false;
string strDir = "";
do
{
if (dirPath[dirPath.Length - i] != '\\')
{
strDir = dirPath[dirPath.Length - i] + strDir;
i++;
}
else
{
ketemu = true;
}
} while (!ketemu);
return strDir;
}
private void DirSearch(string strDir)
{
intJumlahHasil = lvwHasil.Items.Count + 1;
string P = txtPattern.Text;
string T;
if (boolHentikan) return;
try
{
foreach (string strFiles in Directory.GetFiles(strDir))
{
Application.DoEvents();
if (boolHentikan) return;
T = Path.GetFileName(strFiles);
tssLblOnScanning.Text = "Periksa File : " + T;
this.Update();
if (!cbxSensitif.Checked)
138
{
P = P.ToLower();
T = T.ToLower();
}
switch (cbxPilihAlgoritma.Text)
{
case "Brute-Force":
if (BFSearch(P.Length, T.Length, P, T))
{
intFileKetemu++; // jumlah file ketemu
lviHasil = new ListViewItem();
lviHasil.Text = intJumlahHasil.ToString();
lviHasil.Tag = strFiles;
// buat 2 listviewsubitems
lvsiHasil = new ListViewItem.ListViewSubItem();
lvsiHasil.Text = strFiles;
lviHasil.SubItems.Add(lvsiHasil);
lvsiHasil = new ListViewItem.ListViewSubItem();
lvsiHasil.Text = "File";
lviHasil.SubItems.Add(lvsiHasil);
// masukkan listviewitem ke listview
this.lvwHasil.Items.Add(lviHasil);
this.lvwHasil.Update();
intJumlahHasil++; //tambahkan otomatis file ke
listview
}
break;
case "Knuth-Morris-Pratt":
if (KMPSearch(P.Length, T.Length, P, T))
{
intFileKetemu++; // jumlah file ketemu
lviHasil = new ListViewItem();
lviHasil.Text = intJumlahHasil.ToString();
lviHasil.Tag = strFiles;
// buat 2 listviewsubitems
lvsiHasil = new ListViewItem.ListViewSubItem();
lvsiHasil.Text = strFiles;
lviHasil.SubItems.Add(lvsiHasil);
lvsiHasil = new ListViewItem.ListViewSubItem();
lvsiHasil.Text = "File";
lviHasil.SubItems.Add(lvsiHasil);
// masukkan listviewitem ke listview
this.lvwHasil.Items.Add(lviHasil);
this.lvwHasil.Update();
intJumlahHasil++; //tambahkan otomatis file ke
listview
}
break;
case "Boyer-Moore":
if (BMSearch(P.Length, T.Length, P, T))
{
intFileKetemu++; // jumlah file ketemu
lviHasil = new ListViewItem();
lviHasil.Text = intJumlahHasil.ToString();
lviHasil.Tag = strFiles;
// buat 2 listviewsubitems
lvsiHasil = new ListViewItem.ListViewSubItem();
lvsiHasil.Text = strFiles;
lviHasil.SubItems.Add(lvsiHasil);
139
lvsiHasil = new ListViewItem.ListViewSubItem();
lvsiHasil.Text = "File";
lviHasil.SubItems.Add(lvsiHasil);
// masukkan listviewitem ke listview
this.lvwHasil.Items.Add(lviHasil);
this.lvwHasil.Update();
intJumlahHasil++; //tambahkan otomatis file ke
listview
}
break;
}
}
}
catch (Exception ex)
{
//MessageBox.Show(ex.Message);
}
}
private void DirRecursiveSearch(string strDir)
{
intJumlahHasil = lvwHasil.Items.Count + 1;
string P = txtPattern.Text;
string T;
if (boolHentikan) return;
try
{
foreach (string strDirs in Directory.GetDirectories(strDir))
{
Application.DoEvents();
if (boolHentikan) return;
T = GetDirectoryName(strDirs);
tssLblOnScanning.Text = "Periksa Folder : " + strDirs;
this.Update();
if (!cbxSensitif.Checked)
{
P = P.ToLower();
T = T.ToLower();
}
switch (cbxPilihAlgoritma.Text)
{
case "Brute-Force":
if (BFSearch(P.Length, T.Length, P, T))
{
intFolderKetemu++; //jumlah folder ketemu
lviHasil = new ListViewItem();
lviHasil.Text = intJumlahHasil.ToString();
lviHasil.Tag = strDirs;
// buat 2 listviewsubitems
lvsiHasil = new ListViewItem.ListViewSubItem();
lvsiHasil.Text = strDirs;
lviHasil.SubItems.Add(lvsiHasil);
lvsiHasil = new ListViewItem.ListViewSubItem();
lvsiHasil.Text = "Folder";
lviHasil.SubItems.Add(lvsiHasil);
// masukkan listviewitem ke listview
this.lvwHasil.Items.Add(lviHasil);
this.lvwHasil.Update();
intJumlahHasil++; //tambahkan otomatis file ke
listview
}
break;
case "Knuth-Morris-Pratt":
140
if (KMPSearch(P.Length, T.Length, P, T))
{
intFolderKetemu++; //jumlah folder ketemu
lviHasil = new ListViewItem();
lviHasil.Text = intJumlahHasil.ToString();
lviHasil.Tag = strDirs;
// buat 2 listviewsubitems
lvsiHasil = new ListViewItem.ListViewSubItem();
lvsiHasil.Text = strDirs;
lviHasil.SubItems.Add(lvsiHasil);
lvsiHasil = new ListViewItem.ListViewSubItem();
lvsiHasil.Text = "Folder";
lviHasil.SubItems.Add(lvsiHasil);
// masukkan listviewitem ke listview
this.lvwHasil.Items.Add(lviHasil);
this.lvwHasil.Update();
intJumlahHasil++; //tambahkan otomatis file ke
listview
}
break;
case "Boyer-Moore":
if (BMSearch(P.Length, T.Length, P, T))
{
intFolderKetemu++; //jumlah folder ketemu
lviHasil = new ListViewItem();
lviHasil.Text = intJumlahHasil.ToString();
lviHasil.Tag = strDirs;
// buat 2 listviewsubitems
lvsiHasil = new ListViewItem.ListViewSubItem();
lvsiHasil.Text = strDirs;
lviHasil.SubItems.Add(lvsiHasil);
lvsiHasil = new ListViewItem.ListViewSubItem();
lvsiHasil.Text = "Folder";
lviHasil.SubItems.Add(lvsiHasil);
// masukkan listviewitem ke listview
this.lvwHasil.Items.Add(lviHasil);
this.lvwHasil.Update();
intJumlahHasil++; //tambahkan otomatis file ke
listview
}
break;
}
DirSearch(strDirs);
DirRecursiveSearch(strDirs);
}
}
catch (Exception ex)
{
//MessageBox.Show(ex.Message);
}
}
private bool BFSearch(int n, int m, string P, string T)
{
//Deklarasi
int i, j;
bool ketemu;
//Algoritma
i = 0;
ketemu = false;
while (i <= m - n)
141
{
j = 0;
while (j < n && (T[i + j] == P[j]))
{
j++;
}
if (j >= n)
{
ketemu = true;
}
i++;
}
return ketemu;
}
private void HitungPinggiran(int n, string P, int[] kmpNext)
{
//deklarasi
int i, j;
//algoritma
i = 0;
j = -1;
kmpNext[0] = -1;
while (i < n - 1)
{
while (j >= 0 && P[i] != P[j])
{
j = kmpNext[j];
}
i++;
j++;
if (P[i] == P[j])
{
kmpNext[i] = kmpNext[j];
}
else
{
kmpNext[i] = j;
}
}
}
private bool KMPSearch(int n, int m, string P, string T)
{
//deklarasi
int i, j, next;
bool ketemu;
int[] kmpNext = new int[n];
//preprocessing
HitungPinggiran(n, P, kmpNext);
//algoritma
i = 0;
ketemu = false;
while (i <= m - n)
{
j = 0;
while (j < n && T[i + j] == P[j])
{
j = j + 1;
}
if (j >= n)
{
ketemu = true;
next = j;
}
else
{
next = j - kmpNext[j];
}
142
i = i + next;
}
return ketemu;
}
private void BadCharacter(string P, int n, int[] bmBC)
{
int i, j;
for (i = 0; i < 255; i++)
{
bmBC[i] = -1;
}
for (j = 0; j < n - 1; j++)
{
bmBC[P[j]] = n - j - 1;
}
}
private void Suffix(string P, int n, int[] suff)
{
int f, g, i;
f = -1;
suff[n - 1] = n;
g = n - 1;
for (i = n - 2; i >= 0; --i)
{
if (i > g && suff[i + n - 1 - f] < i - g)
{
suff[i] = suff[i + n - 1 - f];
}
else
{
if (i < g)
{
g = i;
}
f = i;
while (g >= 0 && P[g] == P[g + n - 1 - f])
{
--g;
}
suff[i] = f - g;
}
}
}
private void GoodSuffix(string P, int n, int[] bmGS)
{
int i, j;
int[] suff = new int[n];
Suffix(P, n, suff);
for (i = 0; i < n - 1; ++i)
{
bmGS[i] = n;
}
j = 0;
for (i = n - 1; i >= -1; --i)
{
if (i == -1 || suff[i] == i + 1)
{
for (j = 0; j < n - 2 - i; ++j)
{
if (bmGS[j] == n)
{
bmGS[j] = n - 1 - i;
143
}
}
}
}
for (i = 0; i <= n - 2; ++i)
{
bmGS[n - 1 - suff[i]] = n - 1 - i;
}
}
private bool BMSearch(int n, int m, string P, string T)
{
int i, j, bmBCShift, bmGSShift, shift;
int[] bmBC = new int[255];
int[] bmGS = new int[n];
bool ketemu;
//preprocessing
BadCharacter(P, n, bmBC);
GoodSuffix(P, n, bmGS);
//searching
i = 0;
ketemu = false;
while (i <= m - n)
{
j = n - 1;
while (j >= 0 && T[i + j] == P[j])
{
j = j - 1;
}
if (j < 0)
{
ketemu = true;
i += bmGS[0];
}
else
{
bmBCShift = bmBC[T[i + j]] - n + 1 + j;
bmGSShift = bmGS[j];
shift = Math.Max(bmGSShift, bmBCShift);
i += shift;
}
}
return ketemu;
}
}
}