Paper Analisis Desain dan Algoritma
ANALISIS ALGORITMA INSERTION SORT
DAN ALGORITMA PENCOCOKAN STRING KNUTH-MORRIS-PRATT
Katya Lindi Chandrika1), Ni’matul Rochmaniyah2), Trias Nur Ilmiani3)
1)2)3)
Teknik Informatika Universitas Negeri Malang
Jl. Semarang No. 5, Malang – Jawa Timur
email: katyachandrika@gmail.com1), rohmania1102@gmail.com2), trias.nuri@gmail.com3)
Abstrak—Dalam kehidupan sehari-hari
pengguna komputer seringkali dihadapkan pada
masalah pengurutan data dan pencarian string.
Mengingat pentingnya kedua hal tersebut maka pada
makalah ini dilakukan analisis mengenai efisiensi
algoritma yang digunakan. Semakin efisien suatu
algoritma, maka pada saat dieksekusi dan dijalankan
akan menghabiskan waktu yang lebih cepat.
Algoritma yang diimplementasikan pada makalah ini
adalah algoritma insertion sort untuk pengurutan dan
algoritma Knuth-Morris-Pratt untuk pencarian string.
Analisis yang dilakukan adalah analisis teoritis dan
eksperimental. Analisis teoritis dari algoritma
insertion sort untuk best case adalah O(n) (linier) dan
untuk worst case O(n2) (kuadratik). Pada analisis
eksperimental menunjukkan bahwa waktu dan
banyaknya data yang diurutkan berbanding lurus
sehingga memiliki kompleksitas linier dan pada worst
case waktu akan bertambah apabila data yang
diurutkan lebih banyak, sehingga kompleksitas
waktunya kuadratik. Untuk algoritma KMP secara
teori memiliki kompleksitas linier yaitu O(n), dan
untuk hasil eksperimentalnya adalah waktu yang
dibutuhkan dengan banyaknya teks dan pola adalah
berbanding lurus. Hal ini menunjukkan bahwa
kompleksitas waktu algoritma KMP adalah linier,
sehingga dapat dikatakan bahwa analisis teoritis dan
analisis eksperimental pada algoritma insertion sort
dan algoritma Knuth-Morris-Pratt menghasilkan
kompleksitas waktu yang sama.
Kata kunci—sorting, insertion sort, string matching,
Knuth-Morris-Pratt
I. Pendahuluan
Seringkali pengguna komputer (user)
dihadapkan pada kondisi dimana data pada sebuah
array tidak terurut dengan baik. Sementara pada
beberapa pengolahan data, data terurut merupakan
suatu kebutuhan yang harus dipenuhi. Dengan data
yang terurut, pengambilan atau pengaksesan data
akan menjadi lebih efisien dan cepat. untuk itu
diperlukan suatu algoritma yang dapat
mengurutkan elemen-elemen array.
Terdapat beberapa jenis algoritma pengurutan
diantaranya insertion sort, selection sort, shell sort,
bubble sort, heapsort, quicksort, mergesort dan
radix sort. Untuk dapat mengetahui efisiensi pada
algoritma pengurutan, maka akan dilakukan
analisis pada salah satu jenis algoritma yaitu
insertion sort. Insertion sort adalah algoritma
pengurutan sederhana. cara kerja dari insertion sort
ini adalah mengambil elemen pada iterasi ke-n lalu
meletakannya pada tempat yang sesuai
(Budiarsyah, 2013)
Sementara itu pada kasus lain, pencarian string
adalah hal yang sering dilakukan oleh user dalam
pemrosesan teks. Misal untuk mencari sebuah kata
pada Microsoft word atau editor, atau dalam kasus
lain yang lebih besar lagi, yaitu pencarian kata
kunci pada search engine, seperti google, Yahoo,
dan sebagainya.
Proses pencarian string ini disebut juga dengan
pencocokan string (string matching atau pattern
matching). Ada berbagai algoritma string matching
yang sering digunakan, salah satu diantaranya
adalah Knuth-Morris-Pratt. Cara kerja algoritma
Knuth-Morris-Pratt ini adalah dengan mencocokan
suatu pola kata tertentu terhadap suatu kalimat atau
teks panjang.
Sebelumnya terdapat penelitian yang dilakukan
oleh Ekaputri dan Sinaga (2006) pada makalah
aplikasi algoritma pencarian string Knuth-Morris-
Pratt dalam Permainan Word Search, bahwa
algoritma Knuth-Morris-Pratt memiliki waktu
pencocokan string yang singkat. Sementara untuk
algoritma insertion sort pada makalah kompleksitas
algoritma pengurutan selection sort dan insertion
sort oleh B. Tjaru (2010), menyatakan bahwa
algoritma insertion sort efisien untuk data
berukuran kecil dan merupakan algoritma yang
stabil.
Untuk mengetahui seberapa efisien kedua
algoritma tersebut seperti yang telah dilakukan oleh
kedua penelitian di atas, maka pada makalah ini
akan membahas mengenai analisis algoritma
insertion sort dan algoritma Knuth-Morris-Pratt
menggunakan kompleksitas algoritma atau big-O
notation.
II. Tinjauan Pustaka
2.1 Kompleksitas Algoritma
Kompleksitas algoritma terbagi atas dua, yaitu
kompleksitas waktu dan kompleksitas ruang.
Kompleksitas waktu, T(n), adalah jumlah operasi
yang dilakukan untuk melaksanakan algoritma
sebagai fungsi dari ukuran masukan n. Maka,
dalam mengukur kompleksitas waktu dihitunglah
banyaknya operasi yang dilakukan oleh algoritma.
Idealnya, kita memang harus menghitung semua
operasi yang ada dalam suatu algoritma. Namun,
untuk alasan praktis, cukup menghitung jumlah
operasi abstrak yang mendasari suatu algoritma.
Operasi abstrak ini disebut operasi dasar.
Berikut ini adalah hal-hal yang mempengaruhi
kompleksitas waktu:
1. Jumlah masukan data untuk suatu algoritma
(n).
2. Waktu yang dibutuhkan untuk menjalankan
algoritma tersebut.
3. Ruang memori yang dibutuhkan untuk
menjalankan algoritma yang berkaitan dengan
strutur data dari program.
Kompleksitas mempengaruhi performa atau
kinerja dari suatu algoritma. Kompleksitas dibagi
menjadi 3 jenis, yaitu worst case, best case, dan
average case. Masing-masing jenis kompleksitas
ini menunjukkan kecepatan atau waktu yang
dibutuhkan algoritma untuk mengeksekusi
sejumlah kode.
2.2 Algoritma Insertion Sort
Algoritma insertion sort adalah sebuah
algoritma pengurutan sederhana yang membangun
array untuk diurutkan dalam sebuah list yang
hampir terurut. Algoritma ini lebih efisien dari
algoritma yang lebih canggih seperti quicksort,
heapsort, atau merge sort. (Erzandi, 2009) Cara
kerja insertion sort sebagaimana namanya. Pertama-
tama, dilakukan iterasi, dimana di setiap iterasi
insertion sort memindahkan nilai elemen, kemudian
menyisipkannya berulang-ulang sampai ke tempat
yang tepat. Begitu seterusnya dilakukan. Dari proses
iterasi, seperti biasa, terbentuklah bagian yang telah
di-sorting dan bagian yang belum. (Wisudawan, 2008)
Gambar 1. Sebelum penyisipan
Gambar 2. Setelah penyisipan
Pada Gambar 1 diketahui elemen tabel adalah
x. Elemen x akan digeser ke kanan untuk
disisipkan dengan elemen sebelumnya hingga
ditemukan nilai elemen yang lebih kecil.
Variasi umum dari insertion sort, yang
beroperasi pada array, dapat digambarkan sebagai
berikut:
- Misalkan ada sebuah fungsi yang kemudian
dimasukkan ke nilai urutan awal array.
- Pengoperasian dimulai dari urutan yang paling
akhir dan setiap satu elemen akan
dibandingkan dengan elemen sebelumnya (x-
1) kemudian bergeser ke kanan hingga
menemukan posisi yang tepat.
InsertionSort( A )
Dimana A adalah sebuah array A[1...n]
for j = 2 to length[A]
key = A[ j ]
// put A[j} into the sorted sequence A[1...j-1]
i = j - 1
do A[ i + 1] = A[ i ]
i = i – 1
A[i+1] = key
Berdasarkan pseudocode algoritma insertion
sort di atas terdapat perulangan for dimana j adalah
indeks 2 hingga panjang array A. key adalah
variabel yang menyimpan nilai j dari array A. i
adalah lokasi atau indeks yang berada di sebelah
kiri indeks j. Setelah itu masuk ke perulangan while
untuk membandingkan nilai kedua indeks i dan key
serta memindahkan nilai hingga ke lokasi yang
tepat. Apabila i lebih besar dari 0 dan A[i] lebih
besar dari key, maka akan dilakukan perpindahan
ruang dengan dilakukan penambahan + 1 pada
indeks i. Ini menyatakan bahwa nilai indeks i
berpindah ke kanan. Sementara itu kembali indeks i
untuk dilakukan komparasi (perulangan while) lagi.
Jika i – 1 sama dengan 0 maka break, lalu key
menempati ruang kosong yang berada di sebelah
kiri.
Pada Gambar 3 berikut adalah contoh dari
simulasi insertion sort:
Gambar 3. Simulasi Insertion Sort
InsertionSort( A )
Dimana A adalah sebuah array A[1...n]
for j = 2 to length[A] // n
key = A[ j ] // n- 1
{put A[j} into the sorted sequence A[1...j-1]
i = j – 1 //n - 1
∑𝒏𝒋=𝟐(𝐭𝐣)
do A[ i + 1] = A[ i ] ∑𝒏𝒋=𝟐(𝐭𝐣 − 𝟏)
i = i – 1 ∑𝒏𝒋=𝟐(𝐭𝐣 − 𝟏)
A[i+1] = key //n - 1
Pseudocode Insertion Sort beserta perhitungan
kompleksitasnya
 Berdasarkan input yang diberikan, running
time dari program adalah jumlah dari setiap
langkah yang di-eksekusi sebanyak n kali. Berikut
adalah running time dari algoritma yaitu
penjumlahan running time setiap statement yang di-
eksekusi:
𝑇(𝑛) = 𝑐1𝑛+𝑐2(𝑛 − 1) + 𝑐3(𝑛 − 1) + 𝑐4(𝑛 − 1) +
𝑐5 ∑𝑛𝑗=2(𝑡𝑗) + 𝑐6 ∑𝑛𝑗=2(𝑡𝑗 − 1) + 𝑐7 ∑𝑛𝑗=2(𝑡𝑗 − 1) +
𝑐8(𝑛 − 1)
Dimana T(n) adalah running time, n adalah
banyaknya eksekusi pada statement, dan tj adalah
banyaknya shift (loncatan) atau perulangan while
yang diberikan.
Best case
Best case atau kondisi terbaik yaitu dimana
semua data telah terurut. Untuk setiap j = 2,3,.... n,
kita dapat menemukan A[i] kurang dari atau sama
dengan key dimana i memiliki nilai inisial (j – 1).
Dengan kata lain, ketika i = j – 1, akan selalu
didapatkan key A[i] pada waktu perluangan while
berjalan.
Running time pada best case ini dapat
ditunjukkan dengan an + b dimana konstanta a dan
b bergantung pada statement ci. Sehingga T(n)
adalah fungsi liniear dari n.
𝑇(𝑛) = 𝑎𝑛 + 𝑏 = 𝑂(𝑛)
Worst Case
Worst case atau kondisi terburuk terjadi jika
array diurutkan dalam urutan terbalik yaitu, dalam
urutan menurun (besar ke kecil). Dalam urutan
terbalik, selalu ditemukan A[i] lebih besar dari key
pada perulangan loop. Sehingga, harus
membandingkan setiap elemen A[j] dengan seluruh
urutan elemen sub-array A[1.....j-1] dan juga tj = j
untuk j = 2,3,.... n. Secara ekuivalen, saat perulangan
while keluar disebabkan i telah mencapai indeks 0.
Oleh karena itu, tj = j untuk j = 2,3,...,n dan running
time worst case dapat dihitung menggunakan
persamaan sebagai berikut :
Running time pada worst case ini dapat
dinyatakan sebagai 𝑎𝑛2 + 𝑏𝑛 + 𝑛 , untuk
konstanta a, b dan c bergantung pada statement 𝑐𝑖 .
Oleh karena itu, T(n) adalah fungsi kuadrat dari n.
𝑇(𝑛) = 𝑎𝑛2 + 𝑏𝑛 + 𝑐 = 𝑂(𝑛2 ) …… (8)
Average Case
……(1)
Average case terjadi apabila data yang
diurutkan acak. Key dalam A[i] adalah kurang dari
setengah elemen dalam A[1…..j-1] dan lebih besar
dari setengah lainnya. Hal ini berarti pada kondisi
average, perulangan while harus melalui setengah
jalan melalui subarray A diurutkan [1…j-1] untuk
memutuskan dimana memposisikan key. Ini berarti
tj = j/2.
Meskipun running time average case
adalah setengah dari waktu running time worst
case, average case masih memiliki fungsi kuadrat
dari n.
𝑻(𝒏) = 𝒂𝒏𝟐 + 𝒃𝒏 + 𝒄 = 𝑶(𝒏𝟐 ). ……(9)
2.3 Algoritma String Matching Knuth-Morris-
Pratt
Pencocokan pola dan teks (string matching)
adalah permasalahan dasar untuk pemrosesan teks
yang dilakukan menggunakan komputer. Masalah
pencocokan teks yang paling dasar namun penting
adalah menemukan DNA yang sama atau urutan
protein pada DNA.
Cara kerja algortima string matching ini adalah
dengan mencocokan suatu pola kata tertentu
terhadap suatu kalimat atau teks panjang.
……(4) Algoritma string matching dapat
diklasifikasikan menjadi tiga bagian menurut arah
pencariannya (Charras, C. & Lecroq, T. 1997 )
yaitu :
- From left to right.
Dari arah yang paling alami, dari kiri ke kanan,
yang merupakan arah untuk membaca.
- From right to left
Dari arah kanan ke kiri, arah yang biasanya
menghasilkan hasil terbaik secara partikal.
- In a specific order
Dari arah yang ditentukan secara spesifik oleh
algoritma tersebut, arah ini menghasilkan hasil
terbaik secara teoritis.
Pada paper ini, akan dibahas salah satu contoh
dari algoritma string matching from left to right
yaitu Algoritma Knuth-Morris-Pratt.
Algoritma Knuth-Morris-Pratt dikembangkan
oleh D.E.Knuth, bersama dengan J.H.Morris dan
V.R.Pratt pada tahun 1977. Algoritma ini
merupakan pengembangan dari algoritma Brute
Force.
 Di dalam algoritma Knuth-Morris-Pratt atau KMP Function(T, P)
lebih dikenal dengan KMP, terdapat dua komponen 1. n = T.length
2. m = P.length
penting, yaitu: 3. π = Prefix Function(P)
a. Fungsi prefix, fungsi ini memproses pola untuk 4. q = 0
menemukan prefix pada pola dengan pola itu 5. for i = 1 to n
sendiri. Fungsi ini juga berfungsi untuk 6. while q > 0 and P[q+1] ≠ T[i]
7. q = π[q]
mempermudah pencarian pola di dalam string 8. if P[q+1] == T[i]
agar lebih efisien. 9. q = q + 1
b. Komponen kedua adalah fungsi KMP itu sendiri 10. if q == m
yang berguna untuk menyocokkan pola dengan 11. print “Pattern occurs shift” i – m
teks yang diberikan. 12. q = π[q]

Berikut ini adalah langkah – langkah yang Sebagai contoh, dilakukan pencarian pola P =
dilakukan algoritma KMP dalam proses “abcaby” pada teks T = “abxabcabcaby”. Namun
pencocokkan string yaitu : sebelumnya dilakukan pengisian array prefix yang
1. Masukkan Query kata yang akan dicari. Dengan berfungsi untuk mempermudah proses
permisalan P = Pattern atau pola susunan kata pencocokkan. Pengisian array prefix ini dilakukan
yang dijadikan sebagai contoh atau pola teks pada fungsi Prefix.
yang akan dicari T = Teks atau judul dokumen Fungsi prefix
2. Algoritma KMP mulai mencocokkan pattern
atau pola susunan kata yang dijadikan sebagai i 0 1 2 3 4 5
contoh pada awal teks. Pola (i) a b c a b y
3. Dari kiri ke kanan, algoritma ini akan Prefix(i) 0 0 0 1 2 0
mencocokkan karakter per karakter pattern atau
pola yang dijadikan sebagai contoh dengan Gambar 4. Iterasi pada Fungsi Prefix
karakter di teks yang bersesuaian, sampai salah
satu kondisi berikut dipenuhi : Fungsi prefix bekerja mengisi informasi
- Karakter di pattern atau pola susunan kata panjang karakter terpanjang yang menjadi awalan
yang dijadikan sebagai contoh dan di teks dan akhiran pada pola P. Anggap bahwa array
yang dibandingkan tidak cocok (mismatch). prefix adalah π. Nilai π[0] akan bernilai 0 karena
- Semua karakter di pattern atau pola susunan pada karakter pertama tidak ada yang menjadi
kata yang dijadikan sebagai contoh cocok. awalan dan akhiran. Pertama, untuk mengisi π[1]
Kemudian algoritma akan memberitahukan dilakukan pencocokkan karakter pada j=0 dan i=1.
penemuan di posisi ini Karena karakter ‘a’ dan ‘b’ mismatch, nilai dari
4. Algoritma kemudian menggeser pattern atau π[1] = 0. Kedua, dilakukan k inkremen pada i
pola susunan kata yang dijadikan sebagai sehingga i=2. Dilakukan pencocokkan pada
contoh berdasarkan tabel next, lalu mengulangi karakter ke j=0 dan i=2, sehingga nilai π[2] = 0.
langkah no. 2 sampai pattern atau pola susunan Inkremen pada i sehingga i=3. Karakter j=0 dan i=3
kata yang dijadikan sebagai contoh berada di match, sehingga nilai π[3] adalah j+1 yaitu π[3] =
ujung teks 1. Selanjutnya karakter j=1 dan i=4 match, nilai
π[4] = 2. Terakhir karakter j=2 dan i=5 mismatch,
Seperti yang telah disebutkan sebelumnya, dilakukan pengurangan nilai j sebesar 1 sehingga
algoritma ini memiliki dua komponen penting yaitu j=1. Tukar nilai j dengan nilai π[j], menjadi j=0,
fungsi prefix dan fungsi KMP. Kedua fungsi ini lakukan pengecekan apakah karakter j=0 dan i=5
memiliki banyak kesamaan, karena keduanya match, karena mismatch maka π[5] = 0.
mencocokkan string dengan pola P. Fungsi prefix
mencocokkan P dengan P sendiri, sedangkan fungsi Fungsi KMP
KMP mencocokkan P dengan T, dimana T
merupakan sebuah teks. i 0 1 2 3 4 5 6 7 8 9 10 11
Teks a b x a b c a b c a b y
Prefix Function(P)
Fase 1 a b c a b y
1. m = P.length
2. let π [1…m] be a new array Fase 2 a b c a b y
3. π [1] = 0 Fase 3 a b c a b y
4. k = 0
5. for q = 2 to m Gambar 5. Iterasi pada Fungsi KMP
6. while k > 0 and P[k+1] ≠ P[q]
7. k = π[k] Fungsi KMP akan melakukan pencocokan
8. if P[k + 1] == P[q] terhadap teks T dengan pola P. Pada fase pertama
9. k = k + 1
10. π [q] = k terjadi mismatch pada P[i] dimana i=2 dan T[2],
11. Return π dapatkan informasi dari π[i-1] = 0. Cek kecocokan
antara P[0] dan T[i] jika mismatch lakukan
inkremen pada i. Fase kedua mismatch terjadi pada III. Implementasi
P[5] dan T[8], shift ke kiri sebanyak satu sehinga
P[4] dapatkan nilai π[4]=2, ubah indeks P[2], Pada paper ini, pengujian algoritma insertion
lakukan pengecekan antara T[8] dan P[2] dan sort dan KMP diimplementasikan menggunakan
seterusnya sampai batas pola P. Dari Gambar 4 bahasa pemrograman C++. Di dalam pengujian
dapat diketahui bahwa jika terjadi mismatch, penulis menggunakan hardware dengan spesifikasi
pergeseran dilakukan ke karakter atau kumpulan sebagai berikut:
karakter selanjutnya. Processor Intel(R) Celeron(R) CPU
Fungsi prefix akan membutuhkan waktu sebesar B820 @ 1.70GHz
O(m), sedangkan pencarian pola pada teks atau RAM 4096MB
string membutuhkan waktu O(n), sehingga Sistem Operasi Windows 7 Professional 32-
kompleksitas waktu algoritma KMP adalah bit
O(m+n) dan membutuhkan space sebesar O(m). Tabel 1. Spesifikai Hardware untuk Pengujian
Dalam penyelesaian string matching
menggunakan algoritma KMP akan menghasilkan Source Code Algoritma Insertion Sort
best case, worst case dan average case sebagai
1. void insertion_sort (int A[]) {
berikut: 2. int length = sizeof(A)/sizeof(int);
3. for (int j = 2; j < length; j++) {
Best Case
4. int key = A[j];
Kompleksitas terbaik dari algoritma ini 5. int i = j - 1;
6. while (i > 0 && A[i] > key) {
dinotasikan dengan O(m+n). Hal ini akan terjadi 7. A[i+1] = A[i];
ketika pattern sama dengan karakter teks yang 8. i--;
dicocokkan. 9. }
10. A[i+1] = key;
Worst Case 11. }
12. }
Kompleksitas terburuk dari algoritma ini
dinotasikan dengan O(m*n). kasus terburuk terjadi Source Code Algoritma KMP
apabila terdapat pattern tidak pernah sama dengan
teks yang dicocokkan. 1. void prefix (string p) {
2. int m = p.length();
Misal dengan menggunakan pola “aaaa” 3. pi[0] = 0;
diterapkan pada "aaabcaaabce". Untuk pola ini 4. pi[1] = 0;
array π adalah: | 0 | 1 | 2 | 0 | 0 | 1 | 2 | 3 | 4 | 5 | 0 | 5. int k = 0;
Perhatikan bahwa pada indeks 3, ketika 6. for (int q = 2; q < m; q++) {
7. while (k != 0 && p[k] != p[q-1])
ketidakcocokan terjadi, dan pada indeks tersebut 8. k = pi[k];
bernilai 0 yang artinya ketidaksesuaian terjadi. 9. if (p[k] == p[q-1])
Berdasarkan hasil diatas, ketidaksesuaian dapat 10. k = k + 1;
11. pi[q] = k;
dilakukan paling banyak 2 kali, atau dengan kata 12. }
lain, kita hanya dapat melakukan banyak 13. }
ketidaksesuaian sebagai jumlah karakter cocok 14.
15. bool kmp (string p, string t) {
sejauh ini. 16. int n = t.length();
Jadi setiap kali ketidakcocokan terjadi pada 17. int m = p.length();
indeks i, jumlah maksimum ketidaksesuaian pada 18. prefix(p);
19. int q = 0;
indeks i dapat terjadi paling banyak sama dengn
20. for (int i = 1; i < n; i++) {
jumlah karakter yang cocok sejauh ini. (pada 21. while (q > 0 && p[q] != t[i])
indeks i-1). 22. q = pi[q];
23. if (p[q] == t[i])
24. if (++q == m)
Average Case 25. return true;
Kompleksitas rata-rata dari algoritma ini 26. }
27. return false;
dinotasikan dengan O(n). Kasus rata - rata terjadi 28. }
apabila jumlah iterasi = jumlah perbandingan yang
sukses + jumlah perbandingan yang gagal.

Running time <= n+n

Running time <= 2*n
Sehingga kompleksitas = O(n).
 Pada pengujian kedua algoritma, masing-
masing nomor dilakukan sebanyak 20 kali dan Grafik KMP
dilakukan perhitungan rata-rata untuk
0.02
menghasilkan waktu pemrosesan algoritma. Hasil

t (Waktu)
0.015
pengujian kedua algoritma dapat dilihat pada tabel 0.01
0.005
berikut ini: 0
10 100 1000 10000 10000
t
No n T (Teks)
Best Case Worst Case
1. 10 0.0000 ms 0.0000 ms
2. 100 0.0000 ms 0.0000 ms Best Case Worst Case
3. 1000 0.0000 ms 0.0000 ms
4. 10000 0.0000 ms 0.0003 ms Grafik 2. Kompleksitas KMP (Pengujian Pertama)
5. 100000 0.0000 ms 0.0011 ms
6. 200000 0.0000 ms 0.0030 ms
7. 300000 0.0000 ms 0.0050 ms Grafik KMP
Tabel 2. Hasil Pengujian Algoritma Insertion Sort
0.02

t (Waktu)
0.015
t
No T P 0.01
Best Case Worst Case 0.005
1. 10 10 0.0000 ms 0.0000 ms 0
2. 100 10 0.0000 ms 0.0000 ms 10 100 1000 10000

3. 1000 10 0.0000 ms 0.0000 ms P (Pola)

4. 10000 10 0.0000 ms 0.0015 ms
5. 100000 10 0.0002 ms 0.01635 ms Best Case Worst Case
Tabel 3. Hasil Pengujian Pertama Algoritma KMP
t Grafik 3. Kompleksitas KMP (Pengujian Kedua)
No T P
Best Case Worst Case Grafik 2 merupakan hasil pengujian algoritma
1. 100000 5 0.0000 ms 0.0112 ms
KMP dengan variabel tetap yaitu jumlah pola 10.
2. 100000 10 0.0010 ms 0.01135 ms
Berdasarkan grafik diatas, dapat dilihat bahwa
3. 100000 100 0.0015 ms 0.01235 ms
4. 100000 1000 0.0018 ms 0.0133 ms dalam kondisi best case maupun worst case,
5. 100000 10000 0.0044 ms 0.0152 ms algoritma KMP mengalami peningkatan running
Tabel 4. Hasil Pengujian Kedua Algoritma KMP time jika nilai T (Teks) dan P (Pola) mengalami
kenaikan jumlah. Semakin banyak jumlah pola
yang dicari di dalam teks dengan jumlah besar,
Grafik Insertion Sort maka running time juga semakin tinggi.
0.006
Sedangkan pada Grafik 3 merupakan hasil
0.005 pengujian algoritma KMP dengan variabel tetap
t (Waktu)

0.004 yaitu teks dengan panjang 10000. Hasil yang

0.003
0.002
0.001
0
n (Banyaknya Data)
Best Case Worst Case
Grafik 1. Kompleksitas Insertion Sort
Grafik Insertion Sort diatas menunjukkan
bahwa algoritma tersebut memiliki kompleksitas
yang linier pada kondisi best case dan kuadratik
pada kondisi worst case. Hal ini dapat dilihat pada
grafik diatas bahwa saat kondisi best case,
berapapun data yang dimasukkan akan tetap
membutuhkan running time yang sama. Sedangkan
pada saat kondisi worst case, semakin banyak data
yang dimasukkan, maka running time yang
dibutuhkan juga akan semakin lama.
ditunjukkan sama yaitu terjadi peningkatan running
time jika jumlah pola yang dicari semakin banyak.
IV. Kesimpulan
Pada analisa teoritis algoritma insertion sort
memiliki kompleksitas linier untuk best case,
sedangkan untuk worst case adalah kuadratik.
Begitupun pada analisis eksperimental seperti
ditunjukkan pada grafik 1, menunjukkan bahwa
banyaknya data yang diurutkan berbanding lurus
dengan waktu, sehingga kompleksitas untuk best
case adalah linier. Sedangkan worst case adalah
terjadi peningkatan waktu apabila data yang
diurutkan lebih banyak sehingga kompleksitasnya
kuadratik.
Sementara untuk algoritma KMP string
matching pada analisis teoritis memiliki
kompleksitas linier. Begitupun pada analisa
eksperimental Algoritma KMP waktu proses
pencarian yang dibutuhkan berbanding lurus
dengan panjang teks dan pola. Hal ini menunjukkan
bahwa kompleksitas waktu algortima KMP linier.
 Berdasarkan hasil analisa di atas, dapat
disimpulkan bahwa analisis teoritis dan analisis
eksperimental pada algoritma insertion sort dan
algoritma Knuth-Morris-Pratt menghasilkan
kompleksitas waktu yang sama.

V. Referensi
[1] Cormen, Thomas H, dkk. 2009. Introduction
to Algorithms Third Edition. London: MIT
Press.
[2] Lamhot Sitorus. Algoritma dan
Pemrograman. : Penerbit Andi
[3] Fanani, Ikhsan. 2007. Penggunaan “Big O
Notation” untuk Menganalisa Efisiensi
Algoritma. Bandung : ITB.
[4] Erzandi, Muhammad O. 2007. Algoritma
Pengurutan dalam pemrograman.Bandung :
ITB.
[5] Saptadi, Hendra dan Sari, Desi W. 2012.
Analisi Algoritma Insertion Sort, Merge Sort
dan Implementasinya dalam Bahasa
Pemrograman C++. Palembang : Universitas
Sriwijaya.
[6] Harry Octavianus Purba.2016.Algortima
String Matching Pada Mesin Pencarian.
Bandung: Sekolah Teknik Elektro dan
Informatika.
[7] Budiarsyah, Dibi K. 2013. “Analisis
Kompleksitas Waktu Untuk Beberapa
Algoritma Pengurutan”. Bandung : Institut
Teknologi Bandung.
[8] Y. A. S. Gahayu Handari Ekaputri, Aplikasi
Algoritma Pencarian String Knuth-Morris-
Pratt, pp. 2-3, July 2006.
[9] B. Tjaru, Setia N. 2010. Kompleksitas
Algoritma Pengurutan Selection Sort dan
Insertion Sort. Bandung : Institut Teknologi
Bandung.