analisis dan penerapan algoritma string matching...

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

https://gitlab.com/soevar/inf2007_191

ii



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



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(





6. ) boolean

7.

8. Deklarasi


10. j : integer { pointer dari pattern }

11. next : integer { menampung jumlah pergeseran }


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(



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(




5. input T :string { string teks }

6. ) boolean

7.

8. Deklarasi



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(



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 (



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 }


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(



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 }




6. ) boolean

7.

8. Deklarasi


10. j : integer { ponter dari pattern }


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) while(0<8 and „C‟=‟G‟) hasil kondisi false, keluar dari while, nilai

j=0



3) Posisi i=2



a) while(0<8 and „A‟=‟G‟) hasil kondisi false, keluar dari while, nilai

j=0



4) Posisi i=3



a) while(0<8 and „T‟=‟G‟) hasil kondisi false, keluar dari while, nilai

j=0



5) Posisi i=4



62



j=0



6) Posisi i=5




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


7) Posisi i=6




63


j=0



8) Posisi i=7




j=0



9) Posisi i=8




j=0+1 atau j=1

b) while(0<8 and „A‟=‟C‟) hasil kondisi false, keluar dari while, nilai

j=1



10) Posisi i=9




j=0



11) Posisi i=10




64


j=0+1 atau j=1

b) while(0<8 and „A‟=‟C‟) hasil kondisi false, keluar dari while, nilai

j=1



12) Posisi i=11




j=0



13) Posisi i=12




j=0+1 atau j=1

b) while(1<8 and „T‟=‟C‟) hasil kondisi false, keluar dari while, nilai

j=0



14) Posisi i=13




j=0



15) Posisi i=14



65



j=0



16) Posisi i=15




j=0



17) Posisi i=16




j=0



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 :




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 }


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


n=8


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)


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


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) 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



d. Baris ke-21, kondisi if(P[i]=P[j]) atau if(„A‟=‟G‟) hasil kondisi false


3) Posisi i=2


a) while((0>=0) and ('A'≠'G')) hasil kondisi true. Baris ke-17


b) while((-1>=0) and ('C'≠'0')) hasil kondisi false



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) while((0>=0) and ('G'≠'G')) hasil kondisi false


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


5) Posisi i=4


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


c) while((-1>=0) and ('A'≠'0')) hasil kondisi false





kmpNext[2]=-1

6) Posisi i=5


a) while((0>=0) and ('G'≠'G')) hasil kondisi false



d. Baris ke-21, kondisi if(P[i]=P[j]) atau if('A'='C') hasil kondisi false


7) Posisi i=6


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


c) while((-1>=0) and ('A'≠'0')) hasil kondisi false





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 }




6. ) boolean

7.

8. Deklarasi



11. next : integer { menampung jumlah pergeseran }


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


n=8



P=GCAGAGAG. Isi dari pattern (P) ini yang akan di cari di sebuah teks (T)



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



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


17. Baris ke-19, inisialisasikan nilai nilsi next=1


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


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


c) while(2<8 and „A‟=‟A‟) hasil kondisi true. Baris ke-24, j=j+1


d) while(3<8 and „T‟=‟G‟) hasil kondisi false, keluar dari while-do,

nilai j=3


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) while(0<8 and 'C'='G') hasil kondisi false, keluar dari while-do,

nilai j=0




3) Posisi i=5




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) while(0<8 and 'T'='G') hasil kondisi false, keluar dari while-do,

nilai j=0




5) Posisi i=14


74



a) while(0<8 and 'A'='G') hasil kondisi false, keluar dari while-do,

nilai j=0




6) Posisi i=15



a) while(0<8 and 'T'='G') hasil kondisi false, keluar dari while-do,

nilai j=0




7) Posisi i=16



a) while(0<8 and 'A'='G') hasil kondisi false, keluar dari while-do,

nilai j=0




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 :




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


P=GCAGAGAG


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)


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



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




77

















20) Baris ke-13, set nilai bmBC[i]=-1, bmBC[19]=-1, i= 20































78
















































79
















































80
















































81
















































82
























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


bmBC[„C‟]=6


bmBC[„A‟]=5


bmBC[„G‟]=4


bmBC[„A‟]=3


bmBC[„G‟]=2


83


bmBC[„A‟]=1


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 (



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 }


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


P=GCAGAGAG


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)


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



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



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



false

b. Baris ke-19, periksa kondisi if(j<g), if(5<6), hasil kondisi true




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


c) while(3>=0 and P[3]=P[5]) atau while(3>=0 and „G‟=‟G‟), hasil


d) while(2>=0 and P[2]=P[4]) atau while(2>=0 and „A‟=‟A‟), hasil


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


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



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



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



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



false





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


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(



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


P=GCAGAGAG


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)


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



11. Baris ke-14 merupakan prosedur Suffix, prosedur Suffix akan menghasilkan

tabel nilai suff, prosesnya sudah dipaparkan dan nilai suff seperti Tabel 4.3



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


3) Posisi i=2


4) Posisi i=3


5) Posisi i=4


6) Posisi i=5


7) Posisi i=6


8) Posisi i=7


13. Baris ke-18, set nilai j=0

14. Baris ke-19, merupakan sebuah kondisi for(), proses pengulangan for() akan


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


atau if(6=-1 or 0=7), hasil kondisi false

3) Posisi i=5



4) Posisi i=4



5) Posisi i=3



6) Posisi i=2



7) Posisi i=1



8) Posisi i=0


atau if(0=-1 or 1=1), hasil kondisi true


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




bmGS[1]=7

3. Posisi j=2




bmGS[2]=7

4. Posisi j=3




bmGS[3]=7

5. Posisi j=4




bmGS[4]=7

6. Posisi j=5




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


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


atau if(7=8) hasil kondisi false

2. Posisi j=1



3. Posisi j=2



4. Posisi j=3



5. Posisi j=4



6. Posisi j=5



7. Posisi j=6



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



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


1-1, bmGS[7-0]=6, nilai bmGS[7]=6

3) Posisi i=2


1-2, bmGS[7-0]=5, nilai bmGS[7]=5

4) Posisi i=3


1-3, bmGS[7-2]=4, nilai bmGS[5]=4

5) Posisi i=4


1-4, bmGS[7-0]=3, nilai bmGS[7]=3

6) Posisi i=5


1-5, bmGS[7-4]=2, nilai bmGS[3]=2

7) Posisi i=6


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


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(




5. input T :string { string teks }

6. ) boolean

7.

8. Deklarasi



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


n=8



P=GCAGAGAG. Isi dari pattern (P) ini yang akan dicari disebuah teks(T)



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



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



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) 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‟)


c) while(5>=0 and T[1+5]=P[5]) atau while(5>=0 and „C‟=‟G‟)





nilai bmBCShift=4


nilai bmGSShift=4




3) Posisi i=5








98

c) while(5>=0 and T[5+5]=P[5]) atau while(5>=0 and „G‟=‟G‟)


d) while(4>=0 and T[5+4]=P[4]) atau while(4>=0 and „A‟=‟A‟)


e) while(3>=0 and T[5+3]=P[3]) atau while(3>=0 and „G‟=‟G‟)


f) while(2>=0 and T[5+2]=P[2]) atau while(2>=0 and „A‟=‟A‟)


g) while(1>=0 and T[5+1]=P[1]) atau while(1>=0 and „C‟=‟C‟)


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







c) while(5>=0 and T[12+5]=P[5]) atau while(5>=0 and „C‟=‟G‟)





nilai bmBCShift=4


99


nilai bmGSShift=4




5) Posisi i=16





b) while(6>=0 and T[16+6]=P[6]) atau while(6>=0 and „A‟=‟G‟)





nilai bmBCShift=5


nilai bmGSShift=7




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 :

pdf

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.


123

Gambar ‎4.27 Proses yang sedang berjalan


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.

http://www-igm.univ-mlv.fr/~lecroq/string/string.pdf

http://bebas.vlsm.org/v06/Kuliah/SistemOperasi/BUKU/


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();


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


}

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());

}


{


}

}

private void lvwHasil_DoubleClick(object sender, EventArgs e)

{

try

{

System.Diagnostics.Process.Start(this.lvwHasil.SelectedItems[0].Tag.ToString());

}


{


}

}

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);

}


{

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))

{



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.Text = "File";


// 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))

{
















listview

}

break;

case "Boyer-Moore":

if (BMSearch(P.Length, T.Length, P, T))

{










139








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;


try

{

foreach (string strDirs in Directory.GetDirectories(strDir))

{



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.Tag = strDirs;



lvsiHasil.Text = strDirs;



lvsiHasil.Text = "Folder";






listview

}

break;

case "Knuth-Morris-Pratt":


140

if (KMPSearch(P.Length, T.Length, P, T))

{
















listview

}

break;

case "Boyer-Moore":

if (BMSearch(P.Length, T.Length, P, T))

{
















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;

}

}

}
