Pada bab ini disajikan proses analisis dan pengujian program aplikasi pencarian string dengan menggunakan algortima Maximal Shift, algoritma Optimal Mismatch dan algoritma Quick Search terhadap 20 file teks dengan ukuran berkisar 100 kilobytes dan pada masing-masing file dilakukan pencarian pola sebanyak lima kali dengan panjang pola yang dicari adalah 2, 4, 6, 8 dan 10 karakter sehingga diperoleh 100 buah data. Proses analisis dibagi menjadi dua macam yaitu a priori analysis dan a posteriori testing.
4.1 A Priori Analysis
Pada A Priori Analysis ini dilakukan analisis terhadap algoritma- algoritma yang digunakan yaitu algortima Maximal Shift, algoritma Optimal Mismatch dan algoritma Quick Search. Analisis ini bertujuan untuk menganalisis waktu proses yang dibutuhkan oleh masing-masing algoritma. Analisis lebih ditekankan kepada prosedur-prosedur yang melakukan proses pencarian string dan tidak terhadap semua prosedur yang terdapat pada aplikasi.
Dari hasil analisis ditemukan suatu variabel penentu kompleksitas waktu yang sama pada algortima Maximal Shift, algoritma Optimal Mismatch dan algoritma Quick Search yaitu ukuran panjang teks yang dinyatakan dengan n dan ukuran panjang pola yang dinyatakan dengan m. Namun selain variabel ini terdapat variabel-variabel lain yang ikut menentukan, dan variabel-variabel ini berbeda untuk masing-masing algoritma.
Variabel-variabel inilah yang akan digunakan untuk mengetahui kompleksitas waktu untuk masing-masing algoritma.
4.1.1 Algoritma Maximal Shift
Pada algoritma Maximal Shift ini digunakan enam prosedur yang berperan dalam proses pencarian string, yaitu prosedur minShift, prosedur preQsbc, prosedur orderPattern, prosedur matchShift, prosedur preAdaptedGs dan prosedur maximalShift.
Prosedur MinShift 1. FOR i = 0 TO m-1 2. FOR j = i-1 TO 0 3. IF (x[i] = x[j]) 4. THEN BREAK 5. END IF 6. END FOR 7. minShift[i] = i – j 8. END FOR 9. RETURN
Pada langkah ketiga, sintax dijalankan sebanyak m kali dengan perulangan m kali sehingga fungsi waktu yang terjadi adalah T(m,n) = m2 +m. Pada langkah ketujuh, perulangan dilakukan sebanyak m kali sehingga fungsi waktu yang terjadi adalah T(m,n) = m. Maka total fungsi waktu yang terjadi adalah T(m,n) = m2 +m + m atau T(m,n) = m2 +2m.
Prosedur orderPattern 1. FOR i = 0 TO m 2. Pat[i].loc = i 3. Pat[i].c = x[i] 4. END FOR 5. FOR i = 1 TO m-1 6. FOR j = m-1 DOWN TO i 7. IF (minShift[(x[j])]<minShift[(x[j+1])]) OR ((minShift [(x[j])] = minShift[(x[j+1])]) AND (pat[j-1].loc < pat[j].loc))
8. temp = x[j+1] 9. x[j+1] = x[j] 10. x[j] = temp 11. temp2 = pat[j].loc 12. pat[j].loc = pat[j-1].loc 13. pat[j-1].loc = temp2 14. temp3 = minShift[j] 15. minShift[j] = minShift[j-1] 16. minShift[j-1] = temp3 17. END IF 18. END FOR 19. c = x 20. END FOR 21. RETURN
Maka untuk analisis prosedur OrderPattern ini fungsi waktu yang terjadi adalah: T(m,n) = 2m + 10m2 – 20m + 10 + m -1 +1atau T(m,n) = 10m2 – 17m + 10. Prosedur preQsbc 1. FOR i = 0 to 255 2. qsBc[i] = m + 1 3. END FOR 4. FOR i = 0 to m – 1 5. qsBc[x[i]] = m – i 6. END FOR 7. RETURN
Pada langkah pertama ini dilakukan perintah for yang dijalankan sebanyak 255 kali, maka fungsi waktu yang terjadi adalah T(m,n) = 255. Pada langkah keempat dilakukan perulangan sebanyak m-1 kali sehingga maka fungsi waktu yang terjadi adalah T(m,n) = m-1. Pada langkah ketujuh dilakukan perintah return sebanyak satu kali, maka fungsi waktu yang terjadi adalah T(m,n) = 1. Dari tahapan-tahapan diatas dapat diketahui bahwa prosedur preQsbc mempunyai fungsi waktu T(m,n) = 255 + m - 1 + 1. Sehingga dapat disederhanakan menjadi T(m,n) = 255 + m.
Prosedur matchShift 1. FOR lshift TO m – 1 2. i = ploc
3. FOR i DOWN TO 0 4. IF ( (j = (pat[i].loc – lshift) ) < 0 ) 5. THEN CONTINUE 6. END IF 7. IF ( pat[i].c ≠ x[j] ) 8. THEN BREAK 9. END IF 10. END FOR 11. IF (i < 0) 12. THEN BREAK 13. END FOR 14. RETURN (lshift)
Pada langkah pertama dilakukan perintah for untuk perulangan sebanyak m-1 kali sehingga fungsi waktu yang terjadi adalah T(m,n) = m-1. Pada langkah ketiga perulangan dijalankan sebanyak m kali dan dilakukan sebanyak empat kali sehingga fungsi waktu yang terjadi adalah T(m,n) = 4m. Pada langkah ke-11 perulangan dijalankan sebanyak m-1 dengan dua kali perulangan sehingga fungsi waktu yang terjadi adalah T(m,n) = 2m-2. Fungsi return pada langkah terakhir dilakukan sebanyak 1 kali sehingga fungsi waktu yang terjadi adalah T(m,n) = 1. Dari tahapan-tahapan diatas dapat diketahui bahwa prosedur matchShift mempunyai fungsi waktu T(m,n) = m – 1 + 4m + 2m – 2 + 1 . Sehingga dapat disederhanakan menjadi T(m,n)=7m-2.
Prosedur preAdaptedGs 1. adaptedGs[0] = 1 2. lshift = 1
3. FOR ploc = 1 TO m
4. lshift = matchShift(x, m, ploc, lshift, pat) 5. adaptedGs[ploc] = lshift
6. END FOR
7. FOR ploc = 0 TO m
8. lshift = adaptedGs[ploc] 9. REPEAT WHILE (lshift < m) 10. i = pat[ploc].loc – lshift
11. IF (i < 0) OR (pat[ploc].c ≠ x[i]) 12. THEN BREAK
13. ELSE
14. lshift = lshift + 1
15. lshift = matchShift(x, m, ploc, lshift, pat) 16. END IF
17. END REPEAT 18. adaptedGs[ploc] = lshift 19. END FOR
20. RETURN
Pada langkah satu dan dua, perintah hanya dilakukan masing-masing satu kali sehingga fungsi waktu yang terjadi adalah T(m,n) = 2. Pada langkah ketiga terdapat
perintah for yang menjalankan perulangan sebanyak m kali, perulangan tersebut meliputi prosedur matchShift yang mempunyai fungsi waktu T(m,n) = 7m-2 dan adaptedGs yang dilakukan sebanyak satu kali sehingga fungsi waktunya adalah T(m,n) =7m2-m. Langkah ketujuh hingga langkah ke-11 mempunyai fungsi waktu T(m,n) = 7m3 + 4m2 + 2m +1. Dari tahapan-tahapan diatas dapat diketahui bahwa prosedur preAdaptedGs mempunyai fungsi waktu T(m,n) = 2 + 7m2 – m + 7m3 + 4m2 + 2m +1. Sehingga dapat disederhanakan menjadi T(m,n) = 7m3 + 11m2 + m +3.
Prosedur Optimal Mismatch 1. BEGIN 2. READ (x,y) 3. m = LENGTH(x) 4. n = LENGTH(y) 5. minShift (x,m) 6. preQsbc(x, m, qsBc)
7. orderPattern(x, m, maxshiftPcmp, pat) 8. preAdaptedGs(x, m, adaptedGs, pat) 9. j = 0
10. WHILE j < = n – m 11. i = 0
12. WHILE (i < m) AND (pat[i].c = y[j+pat[i].loc]) i = i + 1
13. IF (i > = m) THEN OUTPUT ( j ) END IF 14. j = j + MAX(adaptedGs[i],qsBc[y[j+m]]) 15. END WHILE 16. END
Untuk mengetahui fungsi waktu dari algoritma Optimal Mismatch, maka dilakukan analisis berikut:
1. Pada langkah kedua dilakukan pembacaan pola dan teks, sehingga fungsi waktunya adalah T(m,n) = 1.
2. Pada langkah ketiga dan keempat dilakukan perhitungan panjang karakter pada pola dan teks, sehingga fungsi waktunya adalah T(m,n) = m + n.
3. Pada langkah kelima dilakukan pemanggilan prosedur minShift yang mempunyai fungsi waktu adalah T(m,n) = m2 + 2m.
4. Pada langkah keenam dilakukan pemanggilan prosedur preQsbc yang mempunyai fungsi waktu adalah T(m,n) = 255 + m.
5. Pada langkah ketujuh dilakukan pemanggilan prosedur orderPattern yang mempunyai fungsi waktu adalah T(m,n) = 10m2 – 17m + 10.
6. Pada langkah kedelapan dilakukan pemanggilan prosedur preAdaptedGs yang mempunyai fungsi waktu adalah T(m,n) = 7m3 + 11m2 + m +3.
7. Pada langkah kesembilan dilakukan inisialisasi j, sehingga fungsi waktu adalah T(m,n) = 1.
8. Pada langkah kesebelas dilakukan inisialisasi j sebanyak n-m kali, sehingga fungsi waktu adalah T(m,n) = n-m.
9. Pada langkah keduabelas perulangan dilakukan sebanyak (n-m) * m sehingga fungsi waktu adalah T(m,n) = mn – m2.
10. Pada langkah ketigabelas perulangan dilakukan sebanyak (n-m) * m sehingga fungsi waktu adalah T(m,n) = mn – m2.
11. Pada langkah keempatbelas perulangan dilakukan sebanyak n-m sehingga fungsi waktu adalah T(m,n) = n – m.
Dari tahapan-tahapan diatas dapat diketahui bahwa prosedur Optimal Mismatch mempunyai fungsi waktu T(m,n) = 1 + m + n + m2 + 2m + 255 + m + 10m2 – 17m + 10 + 7m3 + 11m2 + m + 3 + 1 + n - m + mn – m2 + mn – m2 + n – m. Sehingga dapat disederhanakan menjadi T(m,n) = 7m3 + 20m2 + 2mn – 14m + 3n + 270.
4.1.2 Algoritma Optimal Mismatch
Pada algoritma Optimal Mismatch ini digunakan enam prosedur yang berperan dalam proses pencarian string, yaitu prosedur frekuensi, prosedur preQsbc, prosedur orderPattern, prosedur matchShift, prosedur preAdaptedGs dan prosedur Optimal Mismatch. Prosedur frekuensi 1. FOR i = 0 to 255 2. Freq[i] = 0 3. END FOR 4. FOR i = 0 to n – 1
5. Freq[y[i]] = Freq[y[i]] + 1 6. END FOR
7. RETURN
Pada langkah pertama dilakukan perintah for yang dijalankan sebanyak 256 kali untuk freq[i]. Maka fungsi waktu yang terjadi adalah T(m,n) = 256. Sedangkan pada langkah keempat dilakukan perintah for yang dijalankan sebanyak n dimana n adalah panjang teks, maka fungsi waktu yang terjadi adalah T(m,n) = n. Lalu pada langkah ketujuh terdapat perintah return yang dijalankan sebanyak 1 kali. Maka fungsi waktu yang terjadi adalah T(m,n) = 1. Dari tahapan-tahapan diatas dapat diketahui bahwa prosedur frekuensi mempunyai fungsi waktu T(m,n) =255+n+1 atau T(m,n)=256+n.
Prosedur orderPattern 1. FOR i = 0 to m 2. Pat[i].loc = i 3. Pat[i].c = x[i] 4. END FOR 5. FOR i = 1 to m-1 do 6. FOR j = m-1 DOWN TO 1
7. IF ( freq[(x[j])] > freq[(x[j+1])] ) OR ( (freq [(x[j])] = freq[(x[j+1])] ) 8. AND ( pat[j-1].loc < pat[j].loc) ) THEN
9. temp = x[j+1] 10. x[j+1] = x[j] 11. x[j] = temp
12. temp2 = pat[j].loc 13. pat[j].loc = pat[j-1].loc 14. pat[j-1].loc = temp2 15. END IF 16. END FOR 17. c = x 18. END FOR 19. RETURN
Pada langkah pertama ini dilakukan perintah for yang dijalankan sebanyak m kali, dimana m adalah panjang pola yang dicari dan masing-masing m terjadi perulangan sebanyak dua kali, sehingga T(m,n) = 2m. Pada langkah keenam dilakukan perintah for sebanyak m-1 kali dan terjadi perulangan sebanyak tujuh kali. Perulangan ini juga diulang sebanyak m-1 pada langkah kelima sehingga T(m,n)= (m-1)*(m-1)*7 atau T(m,n)= 7m2 – 14m +7. Pada langkah ke-17 dilakukan perulangan sebanyak m-1, maka fungsi waktu yang terjadi adalah T(m,n) = m-1. Pada langkah ke-19 dilakukan perintah return sehingga fungsi waktu yang terjadi adalah T(m,n) = 1.Dari tahapan-tahapan diatas dapat diketahui bahwa prosedur orderPattern mempunyai fungsi waktu T(m,n) = 2m + 7m2 – 14m +7 + m -1 +1. Sehingga dapat disederhanakan menjadi T(m,n)=7m2 – 11m +7.
Prosedur preQsbc yang digunakan adalah sama dengan prosedur pada algoritma Maximal Shift, sehingga T(m,n) = 255 + m. Prosedur matchShift juga terdapat pada algoritma Maximal Shift, sehingga T(m,n)=7m-2. Demikian halnya juga dengan prosedur preAdaptedGs, sehingga T(m,n) = 7m3 + 11m2 + m +3.
Prosedur Optimal Mismatch 1. BEGIN 2. READ (x,y) 3. m = LENGTH(x) 4. n = LENGTH(y) 5. frekuensi(y, n, freq) 6. preQsbc(x, m, qsBc)
7. orderPattern(x, m, optimalPcmp, pat) 8. preAdaptedGs(x, m, adaptedGs, pat) 9. j = 0
10. WHILE j < = n – m 11. i = 0
12. WHILE (i < m) AND (pat[i].c = y[j+pat[i].loc]) i = i + 1 END WHILE 13. IF (i > = m) THEN OUTPUT ( j ) END IF 14. j = j + MAX(adaptedGs[i],qsBc[y[j+m]]) 15. END WHILE 16. END
Untuk mengetahui fungsi waktu dari algoritma Optimal Mismatch, maka dilakukan analisis berikut:
1. Pada langkah kedua dilakukan pembacaan pola dan teks, sehingga fungsi waktunya adalah T(m,n) = 1.
2. Pada langkah ketiga dan keempat dilakukan perhitungan panjang karakter pada pola dan teks, sehingga fungsi waktunya adalah T(m,n) = m + n.
3. Pada langkah kelima dilakukan pemanggilan prosedur frekuensi yang mempunyai fungsi waktu adalah T(m,n) = 256 + n.
4. Pada langkah keenam dilakukan pemanggilan prosedur preQsbc yang mempunyai fungsi waktu adalah T(m,n) = 255 + m.
5. Pada langkah ketujuh dilakukan pemanggilan prosedur orderPattern yang mempunyai fungsi waktu adalah T(m,n)=7m2 – 11m +7.
6. Pada langkah kedelapan dilakukan pemanggilan prosedur preAdaptedGs yang mempunyai fungsi waktu adalah T(m,n) = 7m3 + 11m2 + m +3.
7. Pada langkah kesembilan dilakukan inisialisasi j, sehingga fungsi waktu adalah T(m,n) = 1.
8. Pada langkah kesebelas dilakukan inisialisasi i sebanyak n-m kali, sehingga fungsi waktu adalah T(m,n) = n-m.
9. Pada langkah keduabelas perulangan dilakukan sebanyak (n-m) * m sehingga fungsi waktu adalah T(m,n) = mn – m2.
10. Pada langkah ketigabelas perulangan dilakukan sebanyak (n-m) * m sehingga fungsi waktu adalah T(m,n) = mn – m2.
11. Pada langkah keempatbelas perulangan dilakukan sebanyak n-m sehingga fungsi waktu adalah T(m,n) = n – m.
Dari tahapan-tahapan diatas dapat diketahui bahwa prosedur Optimal Mismatch mempunyai fungsi waktu T(m,n) = 256 + n + 255 + m + 7m2 – 11m + 7 +7 m3 + 11m2 + m + 3 + m + n + 1 + 256 + n + 1 + n – m + mn – m2 + mn – m2 + n – m. Sehingga dapat disederhanakan menjadi T(m,n) = 7m3 + 16m2 + 2mn – 10m + 5n + 779.
4.1.3 Algoritma Quick Search
Pada algoritma Quick Search ini digunakan dua prosedur yang berperan dalam proses pencarian string, yaitu prosedur preQsbc, dan prosedur Quick Search.
Prosedur Quick Search 1. BEGIN 2. READ (x,y) 3. m = LENGTH(x) 4. n = LENGTH (y) 5. preQsbc(x, m, qsBc) 6. j:=0 7. WHILE ( j <= n – m ) 8. temp:=0 9. FOR i:=0 TO m-1 10. IF x[i+1] = y[j+i+1] 11. THEN temp++ 12. END FOR 13. IF temp = m 14. THEN OUTPUT j
15. j + = QSBC(y[j+m+1]) 16. END
Untuk mengetahui fungsi waktu dari algoritma Quick Search, maka dilakukan analisis berikut:
1. Pada langkah kedua dilakukan pembacaan pola dan teks, sehingga fungsi waktunya adalah T(m,n) = 1.
2. Pada langkah ketiga dan keempat dilakukan perhitungan panjang karakter pada pola dan teks, sehingga fungsi waktunya adalah T(m,n) = m + n.
3. Pada langkah kelima dilakukan pemanggilan prosedur preQsbc yang mempunyai fungsi waktu adalah T(m,n) = 255 + m.
4. Pada langkah keenam dilakukan inisialisasi j, sehingga fungsi waktunya adalah T(m,n) = 1.
5. Pada langkah kedelapan dilakukan inisialisasi temp sebanyak n-m kali, sehingga fungsi waktunya adalah T(m,n) = n - m.
6. Pada langkah kesepuluh dilakukan pengecekan if sebanyak m-1 kali, sehingga fungsi waktunya adalah T(m,n) = m-1.
7. Pada langkah kesebelas dilakukan pengecekan then sebanyak m-1 kali, sehingga fungsi waktunya adalah T(m,n) = m-1.
8. Pada langkah ketigabelas dilakukan pengecekan if sebanyak n-m kali, sehingga fungsi waktunya adalah T(m,n) = n-m.
9. Pada langkah keempatbelas dilakukan instruksi then sebanyak n-m kali, sehingga fungsi waktunya adalah T(m,n) = n-m.
10. Pada langkah terakhir dilakukan instruksi j sebanyak n-m kali, sehingga fungsi waktunya adalah T(m,n)=n-m.
Dari tahapan-tahapan diatas dapat diketahui bahwa prosedur Quick Search mempunyai fungsi waktu T(m,n) = 1+ m+n+ 255+m+1+ n-m+ m-1+ m-1+ n-m+ n-m+ n-m. Sehingga dapat disederhanakan menjadi T(m,n) =5n +255.
4.2 A Posteriori Testing
Pada subbab ini dilakukan pengujian program aplikasi secara langsung dengan mengamati hasil pencarian, waktu pencarian, dan jumlah memory yang dibutuhkan pada proses pencarian. Pengujian ini dilakukan terhadap 20 file teks yang memiliki ukuran yang relatif sama yaitu 100 kilobytes. Hasil pengujian ini yang berupa data hasil pencarian, waktu pencarian dan jumlah memory yang dibutuhkan pada proses pencarian kemudian akan dianalisa secara statistik. Seperti yang telah dituliskan pada Bab 3 bahwa penelitian ini akan menguji hipotesis mengenai ada tidaknya perbedaan rata-rata hasil pencarian, waktu pencarian dan jumlah memory yang dibutuhkan pada proses pencarian untuk algoritma Maximal Shift, algoritma Optimal Mismatch dan algoritma Quick Search.
4.2.1 Data Hasil Percobaan
Data hasil percobaan yang akan disajikan berikut ini adalah hasil dari program aplikasi pencarian string yang dijalankan terhadap 20 file teks dengan masing-masing perulangan sebanyak lima kali sehingga diperoleh 100 buah data. Data lengkap dari hasil percobaan dapat dilihat dilampiran, rata-rata untuk setiap percobaan dapat dilihat pada Tabel 4.1 berikut:
Tabel 4.1 Tabel Hasil Percobaan
Hasil pencarian Waktu pencarian Memory yang dibutuhkan
MS OM QS MS OM QS MS OM QS
rata-rata 512,87 512,87 512,87 338,43 349,77 341,74 53675,16 53646,84 53703,56
Tabel diatas menunjukkan rata-rata dari hasil percobaan, dimana MS menunjukkan algoritma Maximal Shift , OM menunjukkan algoritma Optimal Mismatch dan QS menunjukan algoritma Quick Search.
Dari tabel hasil percobaan diatas dapat diketahui bahwa:
1. Hasil pencarian dari algoritma Maximal Shift, algoritma Optimal Mismatch, dan algoritma Quick Search tidaklah berbeda.
2. Algoritma Optimal Mismatch memiliki waktu pencarian yang paling lambat dibandingkan dengan algoritma Maximal Shift dan algoritma Quick Search.
3. Algoritma Maximal Shift memiliki waktu pencarian yang paling cepat, dan algoritma Quick Search memiliki waktu pencarian yang lebih cepat dari algoritma Optimal Mismatch.
3. Algoritma Quick Search memerlukan pemakaian memory yang paling banyak dibandingkan dengan algoritma Maximal Shift dan algoritma Optimal Mismatch. 4. Algoritma Optimal Mismatch memerlukan pemakaian memory yang paling sedikit,
dan algoritma Maximal Shift memerlukan pemakaian memory yang lebih sedikit dari algoritma Quick Search.
Berikut ini disajikan grafik bar untuk membandingkan rata-rata hasil pencarian string, waktu pencarian string dan jumlah memory yang dibutuhkan pada Gambar 4.1 hingga Gambar 4.3 berikut:
Gambar 4.1 Bar Perbandingan Rata-rata Hasil Pencarian
Gambar 4.3 Bar Perbandingan Rata-rata Pemakaian Memory
Dari sajian diatas dapat disimpulkan bahwa pada perbandingan hasil pencarian string maka ketiga algoritma memiliki hasil yang sama, yaitu ketiga algoritma berhasil menemukan semua pola yang ingin dicari pada teks. Dari perbandingan waktu, algoritma Optimal Mismatch memiliki waktu pencarian yang paling lama dibandingkan dengan algoritma lain dan algoritma Quick Search memiliki waktu pencarian yang lebih lama dibandingkan dengan algoritma Maximal Shift. Sedangkan dari perbandingan pemakaian memory, algoritma Quick Search memiliki pemakaian memory yang paling banyak dibandingkan dengan algoritma lain dan algoritma Maximal Shift memilki pemakaian memory yang lebih banyak dibandingkan dengan algoritma Optimal Mismatch.
Berikutnya akan dilakukan Uji untuk mengetahui perbedaan nilai rata-rata untuk hasil pencarian, waktu pencarian dan jumlah pemakaian memory dari algoritma Maximal Shift, algoritma Optimal Mismatch dan algoritma Quick Search. Sebelumnya akan dilakukan uji normalitas untuk mengetahui kenormalan sebaran data.
4.2.2 Uji Normalitas Data Hasil Percobaan
Uji ini dilakukan dengan menggunakan software SPSS versi 10 dan ringkasan hasil ujinya disajikan pada Tabel 4.2 berikut ini:
Tabel 4.2 Tabel Uji Normalitas
Kolmogorov - Smirnov Mean Std. Deviation Sig. Hasil MS 512,87 812,4116 .000 OM 512,87 812,4116 .000 QS 512,87 812,4116 .000 Waktu MS 338,43 707,2843 .000 OM 349,77 740,3372 .000 QS 341,74 710,2339 .000 Memory MS 53675,16 10,2541 .000 OM 53646,84 10,4415 .000 QS 53703,56 10,2635 .000
Uji Kolmogorov–Smirnov mempunyai hipotesis yang menyatakan bahwa data berdistribusi normal. Pada Tabel 4.2 MS menyatakan algoritma Maximal Shift, OM menyatakan algoritma Optimal Mismatch dan QS menyatakan algoritma Quick Search. Hasil pengujian menghasilkan semua variabel mempunyai nilai Sig. = .000 yang berarti Sig. < 0,05 sehingga Ho untuk semua variabel ditolak yaitu semua data tidak berdistribusi normal. Karena nilai mean hasil pencarian dari ketiga metode tidaklah berbeda, maka tidak perlu dilakukan pengujian lebih lanjut dan dapat disimpulkan bahwa tidak ada perbedaan hasil pencarian dari ketiga algoritma, yang berarti semua algoritma berhasil menemukan pola yang diinginkan pada teks.
4.2.3 Uji Perbedaan Nilai Rata-rata Untuk Waktu Pencarian
Uji ini dilakukan dengan menggunakan software SPSS versi 10 dan ringkasan hasil ujinya disajikan pada Tabel 4.3 berikut ini:
Tabel 4.3 Tabel Uji Kruskal-Wallis Untuk Waktu Pencarian
Ho :
µ
1 =µ
2 =µ
3 H1 :µ
1 ≠µ
2 ≠µ
3Dari tabel output diatas terlihat bahwa statistik hitung Kruskal-Wallis adalah 0,004. Dengan melihat tabel Chi-square, untuk df (derajat kebebasan) = 2 dan tingkat signifikansi (
α
) = 5%, maka didapat statistik tabel = 5,991. Oleh karena statistik hitung < statistik tabel (0,004 < 5,991) maka Ho diterima, yang berarti tidak ada perbedaan yang signifikan pada waktu pencarian di antara ketiga algoritma.4.2.4 Uji Perbedaan Nilai Rata-rata Untuk Pemakaian Memory
Uji ini dilakukan dengan menggunakan software SPSS versi 10 dan ringkasan hasil ujinya disajikan pada Tabel 4.4 berikut ini:
Tabel 4.4 Tabel Uji Kruskal-Wallis Untuk Pemakaian Memory
Ho :
µ
1 =µ
2 =µ
3 H1 :µ
1 ≠µ
2 ≠µ
3Dari tabel output diatas terlihat bahwa statistik hitung Kruskal-Wallis adalah 247,759. Dengan melihat tabel Chi-square, untuk df (derajat kebebasan) = 2 dan tingkat signifikansi (
α
) = 5%, maka didapat statistik tabel = 5,991. Oleh karena statistik hitung > statistik tabel (247,759 > 5,991) maka Ho ditolak, yang berarti ada perbedaan pemakaian memory di antara ketiga algoritma. Maka dihitung:= 2,394 √150,5 = 29,37
│R1 – R2│ = │150,50 – 54,72│ = 95,78 │R1 – R3│ = │150,50 – 246,28│ = 95,78 │R2 – R3│ = │54,72 – 246,28│ = 191,56.
Karena nilai ketiganya lebih besar dari 29,37 berarti ketiga algoritma memiliki nilai tengah yang berbeda-beda. Berdasarkan rank pada tabel 4.4, terlihat bahwa algoritma Optimal Mismatch memiliki jumlah pemakaian memory yang paling sedikit, dan algoritma Quick Search memiliki jumlah pemakaian memory yang paling banyak.
Berikut ini disajikan hasil penelitian dalam bentuk tabel: Tabel 4.5 Tabel Perbandingan
Hasil Pencarian Waktu Pencarian Pemakaian Memory Algo
MS OM QS MS OM QS MS OM QS
MS = = = = > <
OM = = = = < < QS = = = = > >
Uraian-uraian hasil penelitian menunjukkan tidak ada perbedaan yang signifikan antara algortima Maximal Shift, algoritma Optimal Mismatch dan algoritma Quick Search
dilihat dari jumlah hasil pencarian maupun waktu pencarian. Namun terdapat perbedaan yang signifikan jika dilihat dari segi pemakaian memory untuk masing-masing algoritma. Pemakaian memory dari algoritma Quick Search adalah yang paling besar, sedangkan pemakaian memory dari algoritma Maximal Shift lebih besar dari algoritma Quick Search.
4.3 Kelebihan dan Kekurangan Penelitian Kelebihan penelitian ini sebagai berikut:
1. Penelitian ini dapat memberikan perbandingan kinerja pencarian string dilihat dari jumlah hasil pencarian, waktu pencarian dan jumlah memory yang dibutuhkan dalam proses pencarian.
2. Aplikasi yang dirancang mampu mencari pola pada file berformat .TXT Kelemahan penelitian ini sebagai berikut:
1. Program aplikasi yang dirancang terbatas digunakan untuk mencari pola pada file .TXT saja. Untuk file-file jenis seperti .doc , .xls dan lainnya belum dapat dicari oleh program aplikasi ini.
2. Penelitian hanya dilakukan pada satu ukuran file, yaitu berkisar 100 kilobytes, tidak dilakukan pencarian pada file-file yang berukuran lebih besar atau lebih kecil.
