Desain dan Analisis Algoritma

Searching
 MATERI
1. Pengantar Kompleksitas Algoritma.
• Peran Algoritma dalam Komputer
• Pengantar DAA.
• Growth of Functions + Notasi Asymptotic
2. Analisa Kompleksitas:
• Rekursif : Fibonacci
• Sorting: Selection Sort, Insertion Sort, Bubble Sort, Shell Sort, Merge Sort ,
Quick Sort , Heap sort, dec tree, counting Sort, Radix-Sort
• Searching: Sequential Search, Fibonacci Search, Interpolation Search,
Binary Search, Depth First Search (DFS), dan Breadth First Search (BFS).
3. Non-Polynomial Completeness (NPC) dan Non-Polynomial
Hardness (NPH) –Pspace
• Greedy Algorithm
• Dynamic Programming
• Knapsack Problem
• Travelling Salesman Problem
 Searching
• Sequential Search
• Binary Search
• Interpolation Search
• Fibonacci Search
• Depth First Search (DFS)
• Breadth First Search (BFS).
Masalah Search (Pencarian)
• Diberikan suatu key, temukan indeks di array pada elemen tertentu
• Teknik bisa menggunakan vektor, array, file
• Aplikasi : information retrieval, query database, dll

key
 Sequential Search
• Membandingkan key ke setiap elemen, sampai elemen yang benar
ditemukan, dan mengembalikan indeks nya.
Coding - Sequential Search
 Elemen tidak Ditemukan
• Bisa saja key yang dicari
tidak ditemukan di array
tersebut
• Pada kasus ini, harus
dikembalikan indeks khusus,
misal : -1
Analisis Complexity – Sequential Search

• Se efisien apa algoritma tersebut

• Pada kasus search, dapat dihitung jumlah operasi
perbandingan antara data (key) dan elemen array
• Jika ada n-elemen, maka :
• Worst case → n
• Best case → 1
• Average case

• Pada kasus ini dikatakan complexity dari Search dengan

order n adalah O(n)
 Binary Search

• Jika elemen terurut, pencarian dapat dilakukan lebih

baik
• Tebak dari bagian tengah, lalu cari ke arah yang lebih
besar, atau lebih kecil (tergantung yang dicari), dst

Terlalu kecil Terlalu besar

Algoritma Binary Search
• Diketahui array integer yang terurut, dan Strategi –
• suatu nilai integer, yang akan dicari pada array
→ menggunakan pendekatan divide and conquer
Binary
Search
Code – Binary Search
• Divide : diantara 2 – lower bound & upper bound sampai
menemukan key
Elemen Tidak Ditemukan
Elemen Tidak Ditemukan
(con’t)
Analisis Complexity – Binary Search
Worst case:
• Tiap waktu menebak ( ‘guess’), array di-split setengah
• Pada worst case :
• 10 elemen, membuat guess 1 , kemudian
• 5 elemen, membuat guess 2 , kemudian
• 2 elemen, membuat guess 3 , kemudian
• 1 elemen, membuat guess 4, selesai
 Analisis Complexity – Binary Search (con’t)
Worst case
• Jika ada 15 elemen :
• 15 elemen, membuat guess 1 , kemudian
• 7 elemen, membuat guess 2 , kemudian
• 3 elemen, membuat guess 3 , kemudian
• 1 elemen, membuat guess 4, selesai
• Hasil sama, tetapi jika ada 16 sampai 31 elemen perlu 5 guess
• Rumus :

• log2 (n) : jumlah pembagian (divide n dengan 2) sampai 1 elemen

Analisis Complexity – Binary Search (con’t)
Average case
• Jika ada 15 elemen :
• 1 elemen, melakukan 1 guess
• 2 elemen, melakukan 2 guess
• 4 elemen, melakukan 3 guess
• 8 elemen, melakukan 4 guess
• Average (rata-rata): adalah :

• Average case : kurang satu dari worst case

Time Complexity – Binary Search
• Jumlah perbandingan : proporsional dengan tinggi , dari search tree
:
Sequential Search vs Binary Search
Average case
• Sequential Search : Worst case n

• Binary Search : Average case

Worst case

average
 Interpolation Search
• Interpolation Search : perbaikan atas Binary Search untuk
instance, di mana nilai-nilai dalam array yang diurutkan
terdistribusi secara merata.
• Binary Search selalu menuju ke elemen tengah untuk
diperiksa.
• Interpolation Search dapat pergi ke lokasi yang berbeda sesuai
dengan nilai key yang sedang dicari.
• Sebagai contoh, jika nilai key lebih dekat ke elemen terakhir,
Interpolation Search kemungkinan akan memulai pencarian ke
arah sisi akhir.
Konsep interpolasi
3 4 5
1 ? 3

x1 y1 x2 y2
1 1 3 5

X =2
Y=1+(2-1)/(3-1)*(5-1)
=3
 Interpolation Search
Untuk menemukan posisi yang akan dicari, ia menggunakan rumus berikut.
• // Ide rumus adalah mengembalikan nilai pos yang lebih tinggi
// ketika elemen yang dicari lebih dekat ke arr [hi]. Dan
// nilai lebih kecil ketika lebih dekat ke arr [lo]
pos = lo + [(x-arr [lo]) * (hi-lo) / (arr [hi] -arr [Lo])]

arr [] ==> Array di mana elemen perlu dicari

x ==> Elemen yang akan dicari
lo ==> Memulai indeks di arr []
hi ==> Mengakhiri indeks di arr []

Algoritma
Sisa algoritma Interpolasi sama dengan Binary Search, kecuali logika partisi di atas.

Step 1: Dalam suatu loop, hitung nilai "pos" menggunakan rumus posisi probe.
Step2: Jika cocok, kembalikan indeks item, dan exit
Step3: Jika item kurang dari arr [pos], hitung posisi probe dari sub-array kiri. Jika tidak,
hitung yang sama di sub-array kanan.
Step4: Repeat until kecocokan ditemukan atau sub-array berkurang menjadi nol.
// C program to implement interpolation search
#include<stdio.h> Interpolation
// If x is present in arr[0..n-1], then returns
// index of it, else returns -1.
Search
Di bawah ini adalah implementasi dari algoritma.
int interpolationSearch(int arr[], int n, int x)
{ // Driver Code
// Find indexes of two corners int main()
int lo = 0, hi = (n - 1); {
// Since array is sorted, an element present
// Array of items on which search will
// be conducted.
// in array must be in range defined by corner
int arr[] = {10, 12, 13, 16, 18, 19, 20, 21, 22, 23,
while (lo <= hi && x >= arr[lo] && x <= arr[hi])
24, 33, 35, 42, 47};
{
int n = sizeof(arr)/sizeof(arr[0]);
// Probing the position with keeping
// uniform distribution in mind.
int x = 18; // Element to be searched
int pos = lo + (((double)(hi-lo) / (arr[hi]- int index = interpolationSearch(arr, n, x);
arr[lo]))*(x - arr[lo]));
// Condition of target found // If element was found
if (arr[pos] == x) if (index != -1)
return pos; printf("Element found at index %d", index);
// If x is larger, x is in upper part else
if (arr[pos] < x) printf("Element not found.");
lo = pos + 1; return 0;
// If x is smaller, x is in the lower part }
else
hi = pos - 1; } Output:
return -1; } Element found at index 4
Interpolation Search

• Time Complexity:
• Jika elemen terdistribusi seragam, maka O (log log n)).
• Pada worst case, bisa memakan waktu hingga O(n).
 Fibonacci Search
• teknik berbasis perbandingan yang menggunakan angka Fibonacci untuk
mencari elemen dalam array yang terurut.

• Diketahui : array yang diurutkan arr [] dari ukuran n dan

• elemen x yang akan dicari di dalamnya.
• Return index x: if ada dalam array else return -1.

Contoh:
Input: arr [] = {2, 3, 4, 10, 40} , x = 10
Output: 3
Elemen x hadir di indeks 3.

Input: arr [] = {2, 3, 4, 10, 40} , x = 11

Output: -1
Elemen x tidak ada.
 Fibonacci Search
• Persamaan dengan Binary Search:
1. Bekerja untuk array yang diurutkan
2. Algoritma Divide and Conquer.
3. Memiliki time complexity Log n.

• Perbedaan dengan Binary Search:

1. Fibonacci Search : membagi array dalam bagian yang tidak sama
2. Binary Search : menggunakan operator pembagian untuk membagi range.
• Fibonacci Search tidak menggunakan /, tetapi menggunakan + dan -.
• Operator pembagian mungkin mahal (costly) pada beberapa CPU.

3. Fibonacci Search menguji elemen yang relatif lebih dekat pada

langkah selanjutnya. Jadi ketika array input besar yang tidak cocok
dalam cache CPU atau bahkan dalam RAM, Fibonacci Search dapat
berguna.
Fibonacci Search
• Latar Belakang:
Bilangan Fibonacci secara rekursif didefinisikan sebagai :
• F (n) = F (n-1) + F (n-2),
• F (0) = 0, F (1) = 1.

• Bilangan Fibonacci :
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,…

Observasi:
Pengamatan di bawah ini digunakan untuk eliminasi range, dan
karenanya untuk kompleksitas (complexity) O (log (n)).
F (n - 2) &pendekatannya; (1/3) * F (n) dan
F (n - 1) &pendekatannya; (2/3) * F (n).
 Algoritma Lengkap - Fibonacci Search
• arr [0..n-1] : array input
• x : elemen yang akan dicari
1. Temukan Bilangan Fibonacci terkecil yang lebih besar atau sama dengan n. :
== fibM [Bilangan Fibonacci ke-m].
• dua bilangan Fibonacci yang mendahuluinya menjadi fibMm1 [bilangan Fibonacci
ke- (m-1) ] dan fibMm2 [bilangan Fibonacci ke-(m-2}].
2. While array memiliki elemen yang harus diperiksa:
1. Bandingkan x dengan elemen terakhir dari rentang yang dicakup oleh fibMm2
2. if x cocok, return indeks
3. Else if x kurang dari elemen, pindahkan ketiga Fibonacci vaiabel dua Fibonacci ke bawah,
menunjukkan eliminasi sekitar dua-pertiga bagian belakang dari array yang tersisa.
4. Else x lebih besar dari elemen, pindahkan ketiga Fibonacci variabel satu Fibonacci ke
bawah. Reset jarak(offset) ke indeks. Ini menunjukkan eliminasi sekitar sepertiga bagian
depan dari array yang tersisa.

3. Karena mungkin ada satu elemen tersisa untuk perbandingan, periksa apakah
fibMm1 adalah 1. Jika Ya, bandingkan x dengan elemen yang tersisa. Jika cocok,
kembalikan indeks.
 Ilustrasi:
Bilangan Fibonacci :
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,…

• memahami algoritma dengan contoh di bawah ini:

• Ilustrasi asumsi: pengindeksan berbasis 1. Elemen target x adalah 85. Panjang

dari array n = 11.
• Bilangan Fibonacci terkecil yang lebih besar dari atau sama dengan 11 adalah
13.
• Sesuai ilustrasi, fibMm2 = 5, fibMm1 = 8, dan fibM = 13.
• variabel offset (nol diinisialisasi).
• nilai offset adalah indeks ; semua indeks termasuk di bawahnya telah
dieliminasi
• Karena fibMm2 menandai kurang lebih sepertiga dari array , serta indeks yang
ditandainya pasti valid, dapat ditambahkan fibMm2 untuk mengimbangi dan
memeriksa elemen pada :
indeks i = min (offset + fibMm2, n).
 Ilustrasi Bilangan Fibonacci :
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,…

Elemen target x adalah 85

indeks i = min (offset + fibMm2, n). 85 > Arr[i]

=i

=i

85 < Arr[i]
arr [0..n-1] : array input
x : elemen yang akan dicari
1. Temukan Bilangan Fibonacci terkecil yang Ilustrasi Bilangan Fibonacci :
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,…
lebih besar atau sama dengan n. : == fibM
[Bilangan Fibonacci ke-m].
• dua bilangan Fibonacci yang
mendahuluinya menjadi fibMm1
Elemen target x adalah 85
[bilangan Fibonacci ke- (m-1) ] dan
fibMm2 [bilangan Fibonacci ke-(m-2}].
2. While array memiliki elemen yang harus
diperiksa:
1. Bandingkan x dengan elemen
terakhir dari rentang yang dicakup oleh
fibMm2
2. if x cocok, return indeks
3. Else if x kurang dari elemen,
pindahkan ketiga Fibonacci vaiabel dua
Fibonacci ke bawah, menunjukkan
eliminasi sekitar dua-pertiga bagian
belakang dari array yang tersisa.
4. Else x lebih besar dari elemen,
pindahkan ketiga Fibonacci variabel
satu Fibonacci ke bawah. Reset jarak
(offset) ke indeks. Ini menunjukkan
eliminasi sekitar sepertiga bagian
depan dari array yang tersisa.

3. Karena mungkin ada satu elemen tersisa

untuk perbandingan, periksa apakah fibMm1
adalah 1. Jika Ya, bandingkan x dengan
elemen yang tersisa. Jika cocok, kembalikan
indeks.
 Analisis Time-Complexity
• Worst case : akan terjadi jika
memiliki target di bagian
yang lebih besar dari (2/3)
array,
• Dengan kata lain, kita
menghilangkan (1/3) bagian
yang lebih kecil dari array
setiap waktu.
• Di call sekali untuk n,
kemudian untuk (2/3) n,
kemudian untuk (4/9) n dan
selanjutnya.
Maka:

Untuk n ~ : dilakukan O(n’) perbandingan, sehingga diperlukan O(log(n)) perbandingan

Latihan
Menggunakan list data pada Fibonacci Search, lalukan langkah-
langkah mencari data :
1. x = 90
2. x = 22
3. x = 105