PRAKTIKUM

RANCANGAN ANALISA ALGORITMA

Oleh :

Nama : Anjas Arfansyah

NIM : 1757301027
Kelas : TI 3.C
No.Praktikum : 06/RAA/3.C/TI/2020
Dosen Pengajar : Musta'inul Abdi, SST., M.Kom

TEKNIK INFORMATIKA
TEKNOLGI INFORMASI DAN KOMPUTER
POLITEKNIK NEGERI LHOKSEUMAWE
2020
 DAFTAR ISI

DAFTAR ISI.............................................................................................................i
DAFTAR GAMBAR..............................................................................................iii
DAFTAR TABEL...................................................................................................iv
BAB I PENDAHULUAN........................................................................................1
1.1. Tujuan........................................................................................................1
1.2. Alat dan Bahan..........................................................................................1
1.3. Dasar Teori................................................................................................1
1.3.1. Bubble Sort........................................................................................1
1.3.2. String Matching..................................................................................3
BAB II PEMBAHASAN.........................................................................................5
2.1. Bubble Sort................................................................................................5
2.1.1. Source Code.......................................................................................5
2.1.2. Output.................................................................................................5
2.1.3. Analisa...............................................................................................6
2.2. Bubble Sort Improve.................................................................................9
2.2.1. Analisa...............................................................................................9
2.3. String Matching.........................................................................................9
2.3.1. Source Code.......................................................................................9
2.3.2. Output...............................................................................................10
2.3.3. Analisa.............................................................................................10
2.4. String Matching Improve........................................................................11
2.4.1. Source Code.....................................................................................11
2.4.2. Output...............................................................................................12
2.4.3. Analisa.............................................................................................13
BAB III PENUTUP...............................................................................................14
3.1. Kesimpulan..............................................................................................14
REFERENSI..........................................................................................................15

i
 DAFTAR GAMBAR

Gambar 2-1 Source Code Bubble Sort.....................................................................5

Gambar 2-2 Output Bubble Sort..............................................................................5
Gambar 2-3 Source Code String Matching..............................................................9
Gambar 2-4 Output String Matching.....................................................................10
Gambar 2-5 Source Code String Matching Improve 1..........................................11
Gambar 2-6 Source Code String Matching Improve 2..........................................12
Gambar 2-7 Output String Matching Improve 1....................................................12
Gambar 2-8 Output String Matching Improve 2....................................................12

ii
 DAFTAR TABEL

Tabel 2-1 Tabel Iterasi 1 Bubble Sort......................................................................7

Tabel 2-2 Tabel Iterasi 2 Bubble Sort......................................................................7
Tabel 2-3 Tabel Iterasi 3 Bubble Sort......................................................................8
Tabel 2-4 Tabel Iterasi 4 Bubble Sort......................................................................8

iii
 1 BAB I PENDAHULUAN

1.1. Tujuan
Tujuan yang ingin dicapai dalam praktikum ini antara lain :
1. Mahasiswa/i dapat mengetahui dan memahami bagaimana cara
menyusun dan mengimplementasikan algoritma bubble sort dan string
matching.
2. Mahasiswa/i dapat mengetahui dan memahami bagaimana cara kerja
dari algoritma bubble sort dan string matching.
3. Mahasiswa/i dapat menganalisa kekurangan dari algoritma bubble sort
dan string matching dan memperbaikinya.

1.2. Alat dan Bahan

Sebelum melakukan praktikum bubble sort dan string matching, ada
beberapa alat dan bahan yang harus dipersiapkan atau dimiliki antara lain :
1. 1 unit laptop ASUS processor intel core i3
2. RAM 8gb dan Harddisk 500gb.
3. Aplikasi DEVC++ dan Microsoft office word 2010.

1.3. Dasar Teori

1.3.1. Bubble Sort

Pengurutan merupakan proses dasar yang ada dalam algoritma dan
stuktur data. Algoritma Bubble Sort adalah pengurutan dengan cara
pertukaran data dengan data disebelahnya secara terus menerus sampai
dalam satu iterasi tertentu tidak ada lagi perubahan. Algoritma Bubble Sort
ini merupakan proses pengurutan yang secara berangsur-angsur berpindah
ke posisi yang tepat [1].
Algoritma Bubble Sort ini merupakan proses pengurutan yang secara
berangsur-angsur berpindah ke posisi yang tepat karena itulah dinamakan

1
Bubble yang artinya gelembung. Algoritma ini akan mengurutkan data dari
yang terbesar ke yang terkecil (ascending) atau sebaliknya (descending).
Untuk belajar algoritma Bubble Sort ini kita hanya perlu memahami
cara yang digunakan untuk mengurutkan data, sederhananya algoritma ini
menggunakan perbandingan dalam operasi antar elemennya. Di bawah ini
merupakan gambaran dari algoritma Bubble Sort dengan array “3 1 4 2 8”.

Proses pertama
(3 1 4 2 8) menjadi (1 3 4 2 8)
(1 3 4 2 8) menjadi (1 3 4 2 8)
(1 3 4 2 8) menjadi (1 3 2 4 8)
(1 3 2 4 8) menjadi (1 3 2 4 8)

Proses kedua
(1 3 2 4 8) menjadi (1 3 2 4 8)
(1 3 2 4 8) menjadi (1 2 3 4 8)
(1 2 3 4 8) menjadi (1 2 3 4 8)
(1 2 3 4 8) menjadi (1 2 3 4 8)

Proses ketiga
(1 2 3 4 8) menjadi (1 2 3 4 8)
(1 2 3 4 8) menjadi (1 2 3 4 8)
(1 2 3 4 8) menjadi (1 2 3 4 8)
(1 2 3 4 8) menjadi (1 2 3 4 8)

Jika kita perhatikan proses diatas, para proses kedua data sudah terurut
dengan benar. Tetapi algoritma Bubble Sort tetap berjalan hingga proses
kedua berakhir. Proses ketiga masih terus berjalan karena pada algoritma
Bubble Sort maksud terurut itu adalah tidak ada satupun penukaran pada
suatu proses. Proses ketiga ini dilakukan untuk verifikasi data [2].

2
 Algoritma Bubble Sort ini mempunyai kelebihan dan kekurangan.
Dua hal inilah yang menjadi pertimbangan programmer ketika membuat
program. Berikut ini beberapa kelebihan yang dimiliki oleh algoritma ini:

 Algoritma ini adalah metode paling sederhana untuk mengurutkan

data.
 Selain sederhana, algoritma ini juga mudah dipahami.
Sedangkan, kekurangan dari algortima ini adalah sebagai berikut:
 Tingkat efisiensinya yang kurang. Bubble Sort ini merupakan metode
pengurutan yang tidak efisien, khususnya ketika menangani data yang
berjumlah besar. Hal tersbeut karena ketika mengurutkan data yang
sangat besar akan sangat lambat prosesnya.
 Jumlah pengulangan yang dilakukan oleh algortima ini akan tetap
sama jumlahnya, meskipun data yang diurutkan sudah cukup terurut
[3].

1.3.2. String Matching

String matching adalah pencarian sebuah pattern pada sebuah teks.
String matching digunakan untuk menemukan suatu string yang disebut
dengan pattern dalam string yang disebut dengan teks. Prinsip kerja
algoritma string matching adalah sebagai berikut:
1. Memindai teks dengan bantuan sebuah window yang ukurannya sama
dengan panjang pattern.
2. Menempatkan window pada awal teks.
3. Membandingkan karakter pada window dengan karakter dari pattern.
Setelah pencocokan (baik hasilnya cocok atau tidak cocok) dilakukan
pergeseran ke kanan pada window. Prosedur ini dilakukan berulang-
ulang sampai window berada pada akhir teks. Mekanisme ini disebut
mekanisme sliding window.
Algoritma string matching mempunyai tiga komponen utama yaitu:

3
1. Pattern, yaitu deretan karakter yang akan dicocokkan dengan teks,
dinyatakan dengan x[0…m − 1], panjang pattern dinyatakan dengan m.
2. Teks, yaitu tempat pencocokan pattern dilakukan. Dinyatakan dengan
y[0 … n − 1], panjang teks dinyatakan dengan n.
3. Alfabet, berisi semua simbol yang digunakan oleh bahasa pada teks dan
pattern, dinyatakan dengan Σ dengan ukuran dinyatakan ASIZE.

Algoritma string matching dapat diklasifikasikan menjadi tiga bagian

menurut arah pencariannya, yaitu:
1. From left to right
Dari arah yang paling alami, dari kiri ke kanan, yang merupakan arah
untuk membaca. Algoritma yang termasuk dalam kategori ini adalah
algoritma Brute Force, algoritma Morris dan Pratt yang kemudian
dikembangkan menjadi algoritma Knuth-Morris-Pratt.
2. From right to left
Dari arah kanan ke kiri, arah yang biasanya menghasilkan hasil terbaik
secara partikal. Contoh algoritma ini adalah algoritma Boyer-Moore,
yang kemudian banyak dikembangkan menjadi algoritma Tuned Boyer-
Moore, algoritma Turbo Boyer-Moore, algoritma Zhu Takaoka dan
algoritma Horspool.
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 Colussi dan algoritma Crochemore-perrin
[4].

4
 1 BAB II PEMBAHASAN

2.1. Bubble Sort

2.1.1. Source Code

Gambar 2-1 Source Code Bubble Sort

2.1.2. Output

Gambar 2-2 Output Bubble Sort

2.1.3. Analisa
Deklarasi :
Int n, i, j, temp

5
Input n = 5
Int a[n];

For(i=0; i<n; i++)  (0<5) ? Ya

Input a[i]  a[0] = 2
i++, i=0+1=1
for(i<n)  (1<5) ? Ya
Input a[i]  a[1] = 10
i++, i=1+1=2
for(i<n)  (2<5) ? Ya
input a[i]  a[2] = 4
i++, i=2+1=3
for(a<n)  (3<5) ? Ya
input a[i]  a[3] = 8
i++, i=3+1=4
for(i<n)  (4<5) ? Ya
input a[i]  a[4] = 6
i++, i=4+1=5
for(i<n)  (5<5) ? Tidak

Proses Iterasi Bubble Sort :

For(i=1; i<n; ++i)  (1<5) ? Ya

For(j=0; j<(n-i); ++j)  (0<5-1)  (0<4) ? Ya
If(a[j] > a[j+1])  (a[0] > a[0+1])  (2>10) ? Tidak
++j, j=0+1=1
For(j<(n-i))  (1<(5-1))  (1<4) ? Ya
if(a[j] > a[j+1])  (a[1] > a[1+1])  (10>4) ? Ya
temp = a[j]  temp = a[1]  temp = 10
a[j] = a[j+1]  a[1] = a[1+1]  a[1] = 4
a[j+1] = temp  a[2] = 10
++j, j=1+1=2
For(j<(n-i))  (2<(5-1))  (2<4) ? Ya
if(a[j] > a[j+1])  (a[2] > a[2+1])  (10>8) ? Ya
temp = a[j]  temp = a[2]  temp = 10
a[j] = a[j+1]  a[2] = a[2+1]  a[2] = 8
a[j+1] = temp  a[3] = 10
++j, j=2+1=3
For(j<(n-i))  (3<(5-1))  (3<4) ? Ya
if(a[j] > a[j+1])  (a[3] > a[3+1])  (10>6) ? Ya

6
 temp = a[j]  temp = a[3]  temp = 10
a[j] = a[j+1]  a[3] = a[3+1]  a[3] = 6
a[j+1] = temp  a[4] = 10
++j, j=3+1=4
For(j<(n-i))  (4<(5-1))  (4<4) ? Tidak
++i, i=1+1=2

Tabel 2-1 Tabel Iterasi 1 Bubble Sort

Data Nilai Awal Proses 1 Proses 2 Proses 3 Hasil Iterasi 1
a[0] 2 2
a[1] 10 4 4
a[2] 4 10 8 8
a[3] 8 10 6 6
a[4] 6 10 10

For(i<n)  (2<5) ? Ya
For(j=0; j<(n-i); ++j)  (0<5-2)  (0<3) ? Ya
If(a[j] > a[j+1])  (a[0] > a[0+1])  (2>4) ? Tidak
++j, j=0+1=1
For(j<(n-i))  (1<(5-2))  (1<3) ? Ya
if(a[j] > a[j+1])  (a[1] > a[1+1])  (4>8) ? Tidak
++j, j=1+1=2
For(j<(n-i))  (2<(5-2))  (2<3) ? Ya
if(a[j] > a[j+1])  (a[2] > a[2+1])  (8>6) ? Ya
temp = a[j]  temp = a[2]  temp = 8
a[j] = a[j+1]  a[2] = a[2+1]  a[2] = 6
a[j+1] = temp  a[3] = 8
++j, j=2+1=3
For(j<(n-i))  (3<(5-2))  (3<3) ? Tidak
++i, i=2+1=3

Tabel 2-2 Tabel Iterasi 2 Bubble Sort

Data Nilai Setelah Iterasi 1 Proses 1 Hasil Iterasi 2
a[0] 2 2
a[1] 4 4
a[2] 8 6 6
a[3] 6 8 8
a[4] 10 10

For(i<n)  (3<5) ? Ya
For(j=0; j<(n-i); ++j)  (0<5-3)  (0<2) ? Ya
If(a[j] > a[j+1])  (a[0] > a[0+1])  (2>4) ? Tidak

7
 ++j, j=0+1=1
For(j<(n-i))  (1<(5-2))  (1<2) ? Ya
if(a[j] > a[j+1])  (a[1] > a[1+1])  (4>6) ? Tidak
++j, j=1+1=2
For(j<(n-i))  (2<(5-2))  (2<2) ? Tidak
++i, i=3+1=4

Tabel 2-3 Tabel Iterasi 3 Bubble Sort

Data Nilai Setelah Iterasi 2 Hasil Iterasi 3
a[0] 2 2
a[1] 4 4
a[2] 8 6
a[3] 6 8
a[4] 10 10

For(i<n)  (4<5) ? Ya
For(j=0; j<(n-i); ++j)  (0<5-4)  (0<1) ? Ya
If(a[j] > a[j+1])  (a[0] > a[0+1])  (2>4) ? Tidak
++j, j=0+1=1
For(j<(n-i))  (1<(5-4))  (1<1) ? Tidak
++i, i=4+1=5

Tabel 2-4 Tabel Iterasi 4 Bubble Sort

Data Nilai Setelah Iterasi 3 Hasil Iterasi 4
a[0] 2 2
a[1] 4 4
a[2] 8 6
a[3] 6 8
a[4] 10 10

For(i<n)  (5<5) ? Tidak

Cetak Hasil Sorting :

For(i=0; i<n; i++)  (0<5) ? Ya
Cetak a[i]  a[0] = 2
i++, i=0+1=1
for(i<n)  (1<5) ? Ya
Cetak a[i]  a[1] = 4
i++, i=1+1=2
for(i<n)  (2<5) ? Ya
Cetak a[i]  a[2] = 6
i++, i=2+1=3

8
 for(a<n)  (3<5) ? Ya
Cetak a[i]  a[3] = 8
i++, i=3+1=4
for(i<n)  (4<5) ? Ya
Cetak a[i]  a[4] = 10
i++, i=4+1=5
for(i<n)  (5<5) ? Tidak

2.2. Bubble Sort Improve

2.2.1. Analisa
Pada program bubble sort, masalah utama yang ada adalah data
terus dicek berulang meskipun data sudah terurut ketika belum
mencapai iterasi maksimal. Solusinya ada yaitu membandingkan
kembali data satu per satu, namun hal ini hanya akan membuat
program memproses lebih lambat karena harus mengeceknya
kembali data satu persatu sehingga untuk saat ini, perbaikan dari
metode bubble sort belum ada. Jika data yang akan disorting sangat
banyak, metode merge sort lebih baik untuk mengurutkan data dalam
jumlah besar atau banyak.

2.3. String Matching

2.3.1. Source Code

Gambar 2-3 Source Code String Matching

9
2.3.2. Output

Gambar 2-4 Output String Matching

2.3.3. Analisa
Pada awal program dideklarasikan variabel kata dan cari dengan
tipe data string. Kemudian diinisialisasi result=-1. Kemudian
diinputkan kalimat dan disimpan dalam variabel kata. Kemudian
diinputkan juga kata yang akan dicari kedalam variabel cari.
Kemudian di proses result = kata.find(cari,result+1). Maksudnya
adalah mencari kata yang terdapat pada string kata mulai dari index
result + 1, yaitu 0. Jika ditemukan, nilai index akan disimpan dalam
variabel result. Kemudian akan dicek, apakah result !=-1 ? jika ya,
maka akan dicetak kata ditemukan pada index ke result. Kemudian
akan dicek apakah result >=0 ? jika ya, maka akan dieksekusi
kembali result = kata.find(cari,result+1). Jika tidak, maka program
akan berhenti.

10
2.4. String Matching Improve
2.4.1. Source Code

Gambar 2-5 Source Code String Matching Improve 1

11
 Gambar 2-6 Source Code String Matching Improve 2

2.4.2. Output

Gambar 2-7 Output String Matching Improve 1

Gambar 2-8 Output String Matching Improve 2

2.4.3. Analisa
String Matching Improve 1
Pada program string matching 1, disini ditambahkan beberapa
syntax untuk mengatasi kekurangan dari metode string matching itu
sendiri yaitu mengatasi masalah sensitive case antara kata yang
dicari dengan string yang ada. Perintah yang ditambahkan terdapat
pada baris 12-15, yaitu pertama diinisialisasi n = kata.length() yaitu
untuk menghitung panjang dari string yang ada untuk dijadikan
parameter pembuatan variabel penampung array dalam tipe data
char. Kemudian dideklarasikan variabel penampung char_array
dengan tipe data char dengan panjang array n+1. Kemudian di copy
string kata kedalam variabel char_array menggunakan perintah
strcpy. Dalam proses copy ini digunakan fungsi c_str() yang berarti
string dicopy karakter per karakter. Kemudian di proses kata =
strlwr(char_array). Disini terjadi proses mengubah semua karakter
dari huruf besar ke huruf kecil, hasilnya disimpan dalam variabel
kata. Kemudian baru dilakukan proses pencarian. Dan ditambahkan
juga pada perintah 25 untuk menghitung jumlah kata yang
ditemukan. Ditambahkan pula pada baris 28-35 perintah if else untuk

12
melihat data ditemukan atau tidak. Di if else ini di cek apakah
variabel jumpa!=0, jika ya, maka akan dicetak data ditemukan dan
jumlahnya. Jika tidak, akan dicetak data tidak ditemukan.

String Matching Improve 2

Pada program string matching improve 2, disini ditambahkan 1
buah perintah untuk mengatasi masalah kekurangan dari metode
string matching itu sendiri, yaitu jika hanya ingin diketahui apakah
data ada atau tidak saja. Sehingga ketika data sudah menemukan
datanya, program tidak perlu mencari lagi sampai selesai. Adapun
perintah yang ditambahkan ada pada baris 19 yaitu exit(0) dimana
jika data ditemukan atau result != -1, program akan langsung keluar
dari perulangan.

13
 2 BAB III PENUTUP

3.1. Kesimpulan
Pada praktikum kali ini dapat diambil kesimpulan bahwa dari metode
bubble sort, ada kekurangan yaitu masih dilakukannya proses pengurutan
walau data sudah terurut pada iterasi tertentu. Sedangkan pada algoritma
string matching juga masih ada kekurangan, yaitu string yang dicari bersifat
case sensitive yang berarti huruf besar maupun kecil berpengaruh terhadap
hasil pencarian. Sehingga solusi dari kekurangan ini dapat dilakukan proses
downcase atau uppercase.

14
 REFERENSI

[1] A. S. Bancin, “Pengertian Bubble Sort Lengkap Dengan Programnya -

WeareID,” 18-May-2018. [Online]. Available:
https://www.weare.id/pengertian-bubble-sort-lengkap-dengan-
programnya/. [Accessed: 16-Mar-2020].
[2] Musliadi, “Memahami Konsep Bubble Sort (Step by Step) - Musliadi -
Medium,” 06-May-2017. [Online]. Available:
https://medium.com/@musliadi/memahami-konsep-bubble-sort-step-by-
step-cab7fa85edbe. [Accessed: 16-Mar-2020].
[3] R. Abidin, “Algoritma Bubble Sort, Pengertian & Proses Kerjanya,” 27-
Jun-2016. [Online]. Available: https://teknojurnal.com/pengertian-
algoritma-bubble-sort/. [Accessed: 16-Mar-2020].
[4] A. Mutiara Kartika Dewi Nasution, “IMPLEMENTASI ALGORITMA
HORSPOOL DALAM PEMBUATAN KAMUS ISTILAH PSIKOLOGI
PADA PLATFORM ANDROID,” 2016.

15