LAPORAN TUGAS

MATA KULIAH ALGORITMA DAN PEMROGRAMAN LANJUT

Di susun oleh:

Muhammad Naufal Wildan 2009106037

Muhammad Wendra Suryananda 2009106056

Adam Ardhana Putra 2009106105

Nurhidayah Anugrah 2009106121

Muhammad Nur Achwan Pasla 2009106133

PROGRAM STUDI INFORMATIKA FAKULTAS TEKNIK

UNIVERSITAS MULAWARMAN

SAMARINDA

2021
 KATA PENGANTAR

Assalamu’alaikum Warahmatullahi Wabarakatuh

Segala puji syukur kami panjatkan kepada Tuhan Yang Maha Esa. Atas rahmat dan
karunia-Nya, kami dapat menyelesaikan tugas penulisan Laporan Algoritma dan Pemrograman
Lanjut tepat waktu. Tidak lupa shalawat serta salam tercurah kepada Rasulullah SAW yang
syafa’atnya kita nantikan kelak.

Terimakasi kepada Bu Ir. Novianti Puspitasari, M.Eng selaku Dosen Pengampu Mata
Kuliah Algoritma dan Penuli Laporan berjudul “Laporan Tugas”.dapat diselesaikan karena
bantuan banyak pihak. Kami berharap Laporan ini dapat menjadi referensi bagi pihak yang
ingin mengetahui cara membuat suatu program dengan metode sorting dan searching. Selain
itu, kami juga berharap agar pembaca mendapatkan informasi dan pengetahuan baru setelah
membaca laporan ini.

Penulis menyadari laporan tugas ini masih memerlukan penyempurnaan, terutama pada
bagian isi. Kami menerima segala bentuk kritik dan saran pembaca demi penyempurnaan
laporan. Apabila terdapat banyak kesalahan pada laporan ini, kami memohon maaf.

Demikian yang dapat kami sampaikan. Akhir kata, semoga laporan ini dapat
bermanfaat.

Wassalamu’alaikum warahmatullahi wabarakatuh

Samarinda, 6 Maret 2021

Penulis

ii
 DAFTAR ISI

KATA PENGANTAR ......................................................................................................... ii

DAFTAR ISI ....................................................................................................................... iii

DAFTAR GAMBAR .......................................................................................................... iv

BAB I PENDAHULUAN .....................................................................................................1

1. Metode Sorting & Searching .....................................................................................1

1.1 Metode Sorting Merge Sort ................................................................................1

1.2 Metode Searching Fibonacci ..............................................................................2

2. Ilustrasi.......................................................................................................................2

2.1 Ilustrasi Merge Sort ............................................................................................2

2.2 Ilustrasi Fibonacci...............................................................................................4

BAB II PEMBAHASAN .......................................................................................................6

1. Algoritma ....................................................................................................................6

1.1 Algoritma Sorting Merge Sort............................................................................6

1.2 Algoritma Searching Fibonacci ..........................................................................6

2. Program ......................................................................................................................8

2.1 Program Sorting Merge Sort ..............................................................................8

2.2 Program Searching Fibonacci ..........................................................................13

BAB III KESIMPULAN .................................................................................................... 18

DAFTAR PUSTAKA ......................................................................................................... 22

iii
 DAFTAR GAMBAR

Gambar 1.1 Merge Sort Ascending .....................................................................................2

Gambar 1.2 Merge Sort Descending ....................................................................................3

Gambar 1.3 Ilustrasi metode Fibonacci ...............................................................................4

Gambar 2.1 Flowchart Merge Sort .................................................................................... 10

Gambar 2.2 Source Code 1................................................................................................. 11

Gambar 2.3 Source Code 2................................................................................................. 11

Gambar 2.4 Output Merge Sort......................................................................................... 12

Gambar 2.5 Flowchart Fibonacci Search ..........................................................................16

Gambar 2.6 Source Code 1................................................................................................. 17

Gambar 2.7 Source Code 2................................................................................................. 17

Gambar 2.8 Source Code 3................................................................................................. 17

Gambar 2.9 Output Fibonacci Search ............................................................................... 18

iv
 BAB I
PENDAHULUAN
1. Metode Sorting & Searching
1.1 Metode Sorting Merge Sort
Sorting merupakan suatu proses untuk menyusun kembali humpunan obyek
menggunakan aturan tertentu. Sorting disebut juga sebagai suatu algoritma untuk
meletakkan kumpulan elemen data kedalam urutan tertentu berdasarkan satu atau beberapa
kunci dalam tiap-tiap elemen. Pada dasarnya ada dua macam urutan yang biasa digunakan
dalam suatu proses sorting:

1. Urut naik (ascending): Mengurutkan dari data yang mempunyai nilai paling kecil sampai
paling besar

2. Urut turun (descending): Mengurutkan dari data yang mempunyai nilai paling besar
sampai paling kecil.

Algoritma Merge Sort ditemukan oleh John vonNeumann di tahun 1945. Metode
pengurutan merge sort adalah metode pengurutan lanjut, sama dengan metode Quick Sort.
Metode ini juga menggunakan konsep devide and conquer yang membagi data S dalam dua
kelompok yaitu S1 dan S2 yang tidak beririsan (disjoint). Proses pembagian data dilakukan
secara rekursif sampai data tidak dapat dibagi lagi atau dengan kata lain data dalam sub
bagian menjadi tunggal. Setelah data tidak dapat dibagi lagi, proses penggabungan
(merging) dilakukan antara sub-sub bagian dengan memperhatikan urutan data yang
diinginkan (ascending/kecil ke besar atau descending/besar ke kecil). Proses penggabungan
ini dilakukan sampai semua data tergabung dan terurut sesuai urutan yang diiginkan.
Kompleksitas algoritma merge sort adalah O(n log n). Secara umum, algoritma merge sort
dapat diimplementasikan secara rekursif. Fungsi rekursif adalah sebuah fungsi yang
didalam implementasinya memanggil dirinya sendiri. Pemanggilan diri sendiri ini berakhir
jika kondisi tertentu terpenuhi (terminated condition is true). Pada contoh berikut ini,
terminated condition dari proses rekursif mergesort akan berakhir jika data tidak dapat
dibagi lagi (data tunggal telah diperoleh). Dengan kata lain, proses pembagian data
dilakukan terus selama S.size > 1 (belum tunggal).

1
 1.2 Metode Searching Fibonacci
Secara umum search dapat diartikan mencari data dengan cara menelusuri tempat
penyimpanan data tersebut. Tempat penyimpanan data dalam memory dapat berupa array
atau dapat juga dalam bentuk Linked List. Pencarian dapat dilakukan terhadap data yang
secara keseluruhan berada dalam memory komputer ataupun terhadap data yang berada
dalam penyimpanan eksternal (hard disk).

Pada tugas kali ini, kami mendapatkan metode Fibonacci Search. Dimana Fibonacci
Search adalah pencarian sebuah elemen dalam array satu dimensi dengan menggunakan
angka fibonacci sebagai titik-titik (indeks) elemen array yang isinya dibandingkan dengan
nilai yang dicari.Sama halnya dengan Binary Search, Fibonacci Search juga mengharuskan
data yang sudah terurut baik menaik (ascending) maupun menurun (descending).

2. Ilustrasi
2.1 Ilustrasi Merge Sort
Merge Sort Ascending

Gambar 1.1 Merge Sort Ascending

2
 1. Pertama kali larik tersebut dibagi menjadi dua bagian, {F, E, C, A} dan {H, G, B,
D}
2. Kedua larik kemudian diurutkan secara terpisah seinggah menjadi {F, E}, {C, A},
{H, G}, dan {B, D}
3. Ketiga larik kemudian diurutkan secara terpisah sehingga menjadi {F}, {E}, {C},
{A}, {H}, {G}, {B}, dan {D}
4. Sebuah larik baru dibentuk sebagai penggabungan dari setiap dua larik dan
diurutkan, sehingga masing-masing larik memiliki nilai {E, F}, {A, C}, {G, H},
{B, D}
5. Bentuk larik baru lagi yang merupakan penggabungan dari setiap dua larik dan
diurutkan sehingga masing masing larik memiliki nilai {A, C, E, F} dan {B, D, G,
H}
6. Langkah berikutnya adalah penggabungan dari masing-masing larik ke dalam
larik baru yang telah dibuat sebelumnya, sehingga memiliki nilai {A, B, C, D, E,
F, G, H}
Merge Sort Descending

Gambar 1.2 Merge Sort Descending

1. Pertama kali larik tersebut dibagi menjadi dua bagian, {F, E, C, A} dan {H, G, B,
D}

3
 2. Kedua larik kemudian diurutkan secara terpisah seinggah menjadi {F, E}, {C, A},
{H, G}, dan {B, D}
3. Ketiga larik kemudian diurutkan secara terpisah sehingga menjadi {F}, {E}, {C},
{A}, {H}, {G}, {B}, dan {D}
4. Sebuah larik baru dibentuk sebagai penggabungan dari setiap dua larik dan
diurutkan, sehingga masing-masing larik memiliki nilai {F, E}, {C, A}, {H, G},
{D, B}
5. Bentuk larik baru lagi yang merupakan penggabungan dari setiap dua larik dan
diurutkan sehingga masing masing larik memiliki nilai {F, E, C, A} dan {H, G, D,
B}
6. Langkah berikutnya adalah penggabungan dari masing-masing larik ke dalam larik
baru yang telah dibuat sebelumnya, sehingga memiliki nilai {H, G, F, E, D, C, B,
A}

2.2 Ilustrasi Fibonacci

Gambar 1.3 Ilustrasi metode Fibonacci

Penjelasan Slide 1

- Awal masuk program user akan di minta memasukan Batas Deret fibonacci , ilustrasi
diatas si user menginput batas deret fibonaccinya adalah 8.
- Karena User menginput 8 output nya akan tampil 8 bilangan juga.
- Fibonacci adalah suatu barisan bilangan yang merupakan hasil penjumlahan dua
bilangan sebelumnya. Dua bilangan Fibonacci pertama yaitu bilangan 0 dan 1. Sehingga
suku-suku berikutnya dari barisan bilangan Fibonacci yaitu sebagai berikut Bilangan
pertama : 0 , Bilangan kedua : 1 , Bilangan ketiga : 0 + 1 = 1 , bilangan keempat : 1 + 1

4
 = 2 , Bilangan ke lima : 1 + 2 = 3 , bilangan ke enam : 2 + 3 = 5 dan seterunya sehingga
bilangan selanjutnya merupakan penjumlahan dari dua bilangan sebelumnya.
- Ilustrasi program diatas merupakan program fibonacci mengunakan huruf jadi kita
harus mengubah angka menjadi huruf sesuai dengan urutan.angka diawali dengan angka
0 dan huruf diawali dengan huruf A jadi 0=A,1=B,2=C,3=D,4=E,5=F,6=G,7=H
…,…,…,…,…,…,… 23=X,24=Y,25=Z.
- Untuk menampilkan 8 huruf akan di input 2 bilangan pertama terlebih dahulu yaitu 0
dan 1 dimana program dibawah mengunakan huruf jadi yang di tampilkan adalah A dan
B.Jadi deret ke 0 adalah huruf A dan pertama adalah huruf B.
- Untuk mendapatkan deret kedua Huruf A ditambah dengan huruf B hasilnya adalah b
karena A=0 dan B=1 jadi 0+1=1.
- Untuk mendapatkan deret ketiga huruf B ditambah dengan huruf B hasilnya adalah C
karena huruf B nilainya 1 dan huruf C nilainya 2.Jadi deret ke tiga adalah huruf C.
- Untuk mendapatkan deret keempat huruf B ditambah dengan huruf C hasilnya adalah
D karena huruf B nilainya 1,huruf C nilainya 2 dan huruf D nilainya 3.jadi deret ke
empat adalah huruf D.
- Untuk mendapatkan deret kelima huruf C ditambah dengan huruf D hasilnya adalah F
karena huruf C nilainya 2,huruf D nilainya 3 dan huruf F nilainya 5.jadi deret ke lima
adalah huruf F.
- Untuk mendapatkan deret keenam huruf D ditambah dengan huruf F hasilnya adalah I
karena huruf D nilainya 3, huruf F nilainya 5 dan huruf I nilainya 8,jadi deret ke enam
adalah huruf I.
- Untuk mendapatkan deret ketujuh huruf F ditambah dengan huruf I hasilnya adalah N
karena huruf F nilainya 5 , huruf I nilainya 8 dan huruf N nilainya 13 . ke deret ke tujuh
adalah huruf N.

5
 BAB II
PEMBAHASAN
1. Algoritma
1.1 Algoritma Sorting Merge Sort
1. Memulai program
2. Masukkan panjang list huruf yang ingin di input
3. Mengisi huruf sesuai panjang list yang diinputkan
4. Menentukan mid list, left_list dan right list serta mergesort(left_list) dan
(right_list) serta i=0, j=0, k=0
5. Menentukan nilai mergesort ascending dengan perintah kunci
while i<len(left_list) and j<len(right_list):
if ascending:
if left_list[i]<right_list[j]
6. Menentukan nilai shell sort descending dengan perintah kunci sama seperti
langkah sebelumnya namun merubah lambang (<) menjadi (>), sehingga
menjadi
while i<len(left_list) and j>len(right_list):
if ascending:
if left_list[i]<right_list[j]:
7. Program akan mengeksekusi hasil dari penentuan nilai mergesort ascending
dan descending
8. Selanjutnya akan muncul output pengurutan huruf dari abjad awal sampai
abjad akhir yang diinput(ascending)
9. Muncul output pengurutan huruf dari abjad akhir hingga awal yang
diinput(descending)
10. Program selesai

1.2 Algoritma Searching Fibonacci

1. Mulai
2. array ← []
3. stop ← false
4. i ← 0
5. Jika (not stop) maka kerjakan baris 5, jika tidak maka kerjakan baris 11

6
6. test ← masukkan("Masukkan Inputan ke-{} : ".format(j))
7. array.append(test)
8. i ← i +1
9. tanya ← masukkan("mau tambah lagi (y/t): ")
10. Jika == “t” maka kerjakan baris 10, jika tidak maka kerjakan baris 4
11. Stop ← true
12. Keluarkan("Array",array)
13. n ← len(array)
14. x ← (input("masukkan huruf yang dipilih : "))
15. a ← 0
16. b ← 1
17. c ← a + b
18. Jika c < n maka kerjakan baris 18, jika tidak maka kerjakan baris 34
19. a ← b
20. b ← c
21. c ← a + b
22. offset ← -1
23. Jika c > n maka kerjakan baris 23, jika tidak maka kerjakan baris 33
24. i ← min(offset+a, n-1) dan kerjakan baris 22
25. jika array[i] < 1 maka kerjakan baris 25, jika tidak maka kerjakan baris 23
26. c ← b
27. b ← a
28. a ← c - b
29. offset ← i
30. jika array[i] >1 maka kerjakan baris 30, jika tidak maka kerjakan baris 24
31. c ← a
32. b ← b - a
33. a ← c - b
34. jika (b dan array[n-1] == x) maka kerjakan baris 17
35. ind ← FibonacciSearch(array, x, n)
36. jika index >= 0 maka kerjakan baris 39, jika tidak maka kerjakan baris 40
37. keluarkan("index ke-", ind)
38. keluarkan("Tidak ditemukan")
39. Selesai

7
2. Program
2.1 Program Sorting Merge Sort
Muhammad Wendra Suryananda (2009106056)

a. Pseudocode

Program/Judul :
Menentukan huruf ascending dan descending dengan metode mergesort
Deklarasi/Kamus :
mergesort
num = integer
list1 = string
ascending = True
ascending = false
Algoritma :
Input Jumlah list
Input huruf
def mergesort(list1):
if len(list1)>1
mid = len(list1)//2
left_list = list1[:mid]
right_list = list1[mid:]
mergesort(left_list)
mergesort(right_list)
i=0
j=0
k=0
while i<len(left_list) and j<len(right_list):
if ascending:
if left_list[i]<right_list[j]:
i=i+1
k=k+1
else:
list1[k] = right_list[j]

8
 j=j+1
k=k+1
else:
if left_list[i]>right_list[j]:
list1[k] = left_list[i]
i=i+1
k=k+1
else:
list1[k] = right_list[j]
j=j+1
k=k+1
while i<len(left_list):
list1[k] = left_list[i]
i=i+1
k=k+1
while j<len(right_list):
list1[k] = right_list[j]
j=j+1
k=k+1
num = int(input("Masukkan berapa huruf yang anda mau :"))
list1 = [str(input("Masukkan Nilai :")) for x in range (num)]
list_awal = list1.copy()
ascending = True
mergesort(list1)
list_ascending = list1.copy()
list1 = list_awal.copy()
ascending = False
mergesort(list1)
list_descending = list1.copy()
print("Nilai Awal:", list_awal)
print("Nilai Ascending:", list_ascending)
print("Nilai Descending:", list_descending)

9
b. Flowchart

Gambar 2.1 Flowchart Merge Sort

10
c. Program

Gambar 2.2 Source Code 1

Gambar 2.3 Source Code 2

11
 Gambar 2.4 Output Merge Sort

1. def mergesort(list1) :
2. if len(list1)>1:
3. mid = len(list1)//2
4. left_list = list1[:mid]
5. right_list = list1[mid:]
6. mergesort(left_list)
7. mergesort(right_list)
8. i=0
9. j=0
10. k=0
11. while i<len(left_list) and j<len(right_list):
12. if ascending:
13. if left_list[i]<right_list[j]:
14. list1[k] = left_list[i]
15. i=i+1
16. k=k+1
17. else:
18. list1[k] = right_list[j]
19. j=j+1
20. k=k+1
21. else:
22. if left_list[i]>right_list[j]:
23. list1[k] = left_list[i]
24. i=i+1
25. k=k+1
26. else:
27. list1[k] = right_list[j]
28. j=j+1
29. k=k+1
30. while i<len(left_list):
31. list1[k] = left_list[i]
32. i=i+1
33. k=k+1
34. while j<len(right_list):
35. list1[k] = right_list[j]
36. j=j+1
37. k=k+1
38. num = int(input("Masukkan berapa huruf yang anda mau :"))
39. list1 = [str(input("Masukkan Nilai :")) for x in range (num)]
40. list_awal = list1.copy()
41. ascending = True
42. mergesort(list1)
43. list_ascending = list1.copy()
44. list1 = list_awal.copy()
45. ascending = False

12
 46. mergesort(list1)
47. list_descending = list1.copy()
48. print("Nilai Awal:", list_awal)
49. print("Nilai Ascending:", list_ascending)
50. print("Nilai Descending:", list_descending)

d. Penjelasan Program
Pada program pengurutan abjad awal sampai akhir dan sebaliknya saya
menggunakan software python dan sorting mergesort, untuk memulai program saya
menggunakan function mergesort(). selanjutnya saya membuat pernyataan if
len(list1)>1: dan penentuan mid len dan left_list = list1[:mid],right_list = list1[mid:]
mergesort (left_list), mergesort(right_list) i=0; j=0; k=0.
Kemudian, saya membuat kondisi untuk menentukan ascending yang prosesnya bisa
dilihat dari sourcecode diatas. Selanjutnya saya membuat kondisi else yang dimana jika
kondisi salah akan terjadi perubahan ascending menjadi descending sourcecode bisa
dilihat diatas. kemudian kita masuk kedalam proses input panjang list huruf yang
diinginkan. kemudian saya membuat variabel list1 yang dimana isinya berupa tipe data
string untuk menginput huruf yang diinginkan. kemudian saya membuat variabel
pernyataan list_awal yang isinya hanya mengcopy dari variabel list1 agar didapatan list
inputan yang telah diinput. saya membuat variabel ascending yang berisikan True. lalu
saya menampilkan mergesort list1 yang berguna untuk menyusun list1 menjadi
ascending. kemudian saya membuat variabel list_ascending yang berisikan salinan dari
list1. jadi, nilai ascending yang telah ditentukan diatas disalin ke variabel
list_ascending. lalu saya menambahkan variabel list1 yang berisikan list_awal.copy()
gunanya agar menyusun list kembali seperti inputan awal. kemudia saya membuat
variabel ascending yang berisikan False yang berarti merubah ascending menjadi
descending. lalu saya menampilkan mergesort list1 kembali untuk menyusun list
menjadi descending. saya membuat variabel list_descending untuk menyimpan hasil
descendingnya. kemudian muncul output list_awal, list_ascending, dan list_descending.
Program selesai.

2.2 Program Searching Fibonacci

Muhammad Nur Achwan Pasla (2009106133)

a. Pseudocode

13
Program/Judul :
Menentukan huruf ascending dan descending dengan metode mergesort
Deklarasi/Kamus :
ind : Fibonaccisearch(array, x, n)
a, b, c : int(inisialisasi bilangan fibonicca)
array : list
stop : bool
array, x, tanya, test, i : string
n, index : integer
Algoritma :
from bisect import bisect_left

def FibonacciSearch(array, x, n):

a←0
b←1
c←a+b
while (c < n):
a←b
b←c
c←a+b
offset ← -1
while (c > 1):
i ← min(offset+a, n-1)
if (array[i] < x):
c←b
b←a
a←c-b
offset ← i
elif (array[i] > x):
c←a
b←b-a
a←c-b

14
 else:
return i
if(b and array[n-1] == x):
return n-1
return -1

array ← []
stop ← False
i←0
while(not stop):
test ← input("Masukkan Inputan ke-{} : ".format(j))
array.append(test)
i←i+1
tanya = input("mau tambah lagi (y/t): ")
if tanya == "t":
stop ← True
output("Array",array)
n ← len(array)
x ← (input("masukkan huruf yang dipilih : "))
ind ← FibonacciSearch(array, x, n)
if ind >= 0:
output("index ke-", ind)
else:
output("Tidak ditemukan")

b. Flowchart

15
Gambar 2.5 Flowchart Fibonacci Search

16
c. Program

Gambar 2.6 Source Code 1

Gambar 2.7 Source Code 2

Gambar 2.8 Source Code 3

17
 Gambar 2.9 Output Fibonacci Search

1. # kelompok 14 APL program Fibonacci Search (huruf).

2. from bisect import bisect_left
3.
4. def FibonacciSearch(array, x, n):
5.
6. # Insialisai bilangan Fibonacci
7. a = 0 # (m-2)'th nomor Fibonacci
8. b = 1 # (m-1)'th nomor Fibonacci
9. c = a + b # m'th Fibonacci
10.
11. # c akan menyimpan yang terkecil
12. # Bilangan Fibonacci lebih besar atau sama dengan n
13. while (c < n):
14. a = b
15. b = c
16. c = a + b
17.
18. # Tandai jarak yang tereliminasi dari depan
19. offset = -1
20.
21. # Sementara ada elemen yang harus diperiksa. Perhatikan bahwa kami memband
ingkan array[a] dengan x. Ketika c menjadi 1, a menjadi 0
22. while (c > 1):
23.
24. # Periksa apakah a adalah lokasi yang benar
25. i = min(offset+a, n-1)
26.
27. # jika x lebih besar dari nilai pada index a, potong bagian array dari
offset ke i
28. if (array[i] < x):
29. c = b
30. b = a
31. a = c - b
32. offset = i
33.

18
 34. # jika x lebih kecil dari nilai pada index a, potong bagian array sete
lah i+1
35. elif (array[i] > x):
36. c = a
37. b = b - a
38. a = c - b
39.
40. # elemen ditemukan maka kembali ke indeks
41. else:
42. return i
43.
44. # membadingkan elemen lain dengan x
45. if(b and array[n-1] == x):
46. return n-1
47.
48. # elemen tidak ditemukan maka kembali dikurang 1
49. return -1
50.
51. # kode
52. array = []
53. stop = False
54. i = 0
55. while(not stop):
56. test = input("Masukkan Inputan ke-{} : ".format(i))
57. array.append(test)
58. i += 1
59. tanya = input("mau tambah lagi (y/t): ")
60. if tanya == "t":
61. stop = True
62. print(" ")
63. print("Array",array)
64. n = len(array)
65. x = (input("masukkan huruf yang dipilih : "))
66. ind = FibonacciSearch(array, x, n)
67. if ind >= 0:
68. print("index ke-", ind)
69. else:
70. print("Tidak ditemukan")

d. Penjelasan Program
Pada program pencarian saya menggunakan software python dan searching fibonacci,
untuk memulai program saya menggunakan modul bisect karena bisa menggunakan
algoritma bisection dasar untuk melakukan tugasnya dan modul ini menyediakan dukungan
untuk mempertahankan senarai dalam urutan yang telah diurutkan tanpa harus mengurutkan
senarai. Setelah itu saya import ke bisect_left untuk mengembalikan tempat paling kiri di
daftar diurutkan dan memasukkan elemen yang diberikan. Lalu saya mendefinisikan
fibonaccisearch untuk memasukkan rumus pencariannya saya menggunakan variabel
(array, x, n) untuk definisinya. selanjutnya saya memasukkan inisialisai bilangan fibonacci
yang berupa : a = 0; b = 1; c = a + b

19
 Setelah itu kita akan memasuki nilai sementara dari c yang akan menyimpan bilangan
terkecil dan bilangan fibonacci lebih besar atau sama dengan n. sementara c < n maka, a =
b, b = c, dan c = a + b. setelah itu tandai jarak yang sudah tereleminasi dari depan dengan
menggunakan fungsi offset = -1. setelah itu saya memeriksa beberapa elemen dan
membandingkan array[a] dengan x ketika c menjadi 1 dan a menjadi 0. sementara c > 0
maka, i = min(offset+a, n-1). jika array[i] < x maka, c = b, b = a, a = c - b dan offset = i.
jika array[i] > x maka, c = a, b = b - a dan a = c - b. setelah elemen ditemukan kembali lagi
menuju indeks, return i. setelah itu kita membandingkan elemen lain dengan x, jika b dan
array[n-1] sama dengan x maka kembali n dikurangi 1. apabila elemen tidak ditemuka maka
kembali dikurang 1.

Setelah selesai membuat definisi fibonaccisearh saya membuat list abjad agar kita bisa
mengisi dan memilih huruf yang yang kita inginkan yang selanjutnya akan dicari dengan
metode fibonacci search. pertama-tama saya menggunakan fungsi array untuk membuat list
abjad yang kita inginkan dan memanfaatkan metode append agar bisa menambahkan list
sesuai selera kita dengan menanyakan terlebih dahulu ya/tidak untuk penambahannya
apabila tidak maka program akan menampilkan array yang sudah kita isi dan akan
menanyakan huruf apa yang kita cari. setelah memilih hurufnya program akan memasuki

definisi fibonaccisearch untuk mencari index yang kita cari, jika index >=0 maka tampilkan
hasilnya jika tidak maka hasil tidak ditemukan.

Program selesai.

20
 BAB III
KESIMPULAN

Sorting merupakan suatu proses untuk menyusun kembali humpunan obyek

menggunakan aturan tertentu. Salah satu metode sorting yaitu Merge sort. Merge sort
yang menggunakan konsep devide and conquer yang membagi data S dalam dua
kelompok yaitu S1 dan S2 yang tidak beririsan (disjoint).

Searching dapat diartikan mencari data dengan cara menelusuri tempat

penyimpanan data tersebut. Salah satu metode searching yaitu Fibonacci search.
Fibonacci search adalah pencarian sebuah elemen dalam array satu dimensi dengan
menggunakan angka fibonacci sebagai titik-titik (indeks) elemen array yang isinya
dibandingkan dengan nilai yang dicari.

21
 DAFTAR PUSTAKA

https://www.youtube.com/watch?v=_trEkEX_-2Q

https://koding.alza.web.id/algoritma-merge-sort/

http://elektro.um.ac.id/wp-content/uploads/2016/04/MODUL-9-SEARCHING.pdf

http://www.informatika.unsyiah.ac.id/tfa/ds/mergesort.pdf

https://medium.com/daily-python/implementing-fibonacci-search-algorithm-in-python-daily-
python-27-4a6624366022

https://www.geeksforgeeks.org/fibonacci-search/

https://www.youtube.com/watch?v=7Sv4NmvdHcw

https://www.youtube.com/watch?v=N6lEZHGLqu4

22