RESUME ANALISIS ALGORITMA

KHAERYNA ADAM
P3500216017

 Definisi Algoritma
Algoritma : Prosedur komputasional yang terdefinisi dengan baik yang membutuhkan nilai atau
himpunan nilai sebagai Input dan menghasilkan nilai atau himpunan nilai sebagai Output, yang
mana metode penyelesaiannya bersifat logis dan “wajib benar” sesuai dengan keinginan masalah.
Ingat bahwa INPUT dan OUTPUT mutlak ada dalam setiap algoritma.

ALGORITHM

INPUT PROBLEM OUTPUT

 Desain dan Analisis Algoritma

 Pseudocode : Kode untuk memudahkan pemahaman algoritma yang dapat ditransformasi ke
dalam berbagaia macam Bahasa Pemrograman.
 Kompleksitas Algoritma : Analisis kebutuhan algoritma, khususnya waktu komputasi dan
kapasitas memori.
 Strategi Algoritma : Strategi yang dibutuhkan dalam perancangan algoritma (misalnya: Greedy
Algorithm, devide-and-conquer, dynamic programming, dan strategi-strategi algoritma meta-
heuristik untuk masalah optimisasi.
 Struktur data: Menyimpan dan mengorganisasi data untuk kepentingan akses dan modifikasi.
 Masalah NP-Lengkap: Tidak ada solusi efisien.
 Contoh Masalah Komputasi
 SEARCHING PROBLEM
- Input : Barisan n bilangan asli < 𝑎1 , 𝑎2 , … , 𝑎𝑛 > dalam larik A dan sebuah bilangan key
yang ingin dicari.
- Output : Lokasi key dalam A. Jika key tidak ditemukan di dalam A, maka key akan
ditambahkan sebagai unsur terakhir.
 Merancang Algoritma Sederhana
 ALGORITMA LINIER SEARCHING (naïve)
- Menelusuri seluruh indeks A sambil membandingkan apakah unsur dalam indeks A yang
ditelusuri sama dengan key.
- Jika key sama dengan unsur dalam indeks A, maka algoritma berhenti. Namun jika key
tidak ditemukan hingga indeks terakhir dari A, maka key akan ditambahkan sebagai
unsure dari indes terakhir.
- Algoritma berhenti dan kembali ke nilai indeks dari A.
 Note!
Dibutuhkan 2 pernyataan (statement) yaitu:
 Perulangan (looping) untuk menelusuri seluruh indeks A; dan

F
while Logic next block
stat

True stat.

 Penyeleksian syarat untuk membandingkan key dengan unsure dari indeks A yang
ditelusuri.
F
if Logic next block
stat

if block

 Ketentuan Pseudocode
 Indent menyatakan struktur blok.
 Statemen perulangan dikonstruksi dengan while, for dan repeat.
 Statemen penyeleksian syarat/kondisi dikonstruksi dengan if, then dan else.
 Simbol “◊” menyatakan komentar untuk baris-baris berikutnya.
 Penugasan berganda 𝑖 ← 𝑗 ← 𝑒 menyatakan pemberian nilai e ke dalam i dan j; yang
ekuivalen dengan 𝑗 ← 𝑒 lalu diikuti 𝑖 ← 𝑗.
 Pseudocode Algoritma
LINIER-SEARCH(A,key)
1 indeks ← 1;
2 ada ← False;
3 while indeks ≤ length[A] and ada = False
4 if A[indeks] = key then
5 ada ← True;
6 indeks = indeks + 1;
7 indeks = indeks – 1;
8 if ada = False then
9 indeks = length[A] + 1;
10 A[indeks] ← key;
11 return indeks
 SIMULASI
A = [31, 41, 26, 59, 41, 58]
Key = 26
1 indeks = 1
2 ada = False
1 6
3 while (indeks ≤ length[A] ∧ ada = False) ≡ T
T T
1
a) if (A(indeks)= key) ≡ F
31 26
1
b) indeks = length[A] + 1 = 2
2 6
4 while (indeks ≤ length[A] ∧ ada = False) ≡ T
T T
2
a) if (A(indeks)= key) ≡ F
41 26
2
b) indeks = length[A] + 1 = 3
3 6
5 while (indeks ≤ length[A] ∧ ada = False) ≡ T
T T
3
a) if (A(indeks)= key) ≡ T
26 26

a.1) ada = True

3
b) indeks = indeks + 1 = 4
4 6
6 while (indeks ≤ length[A] ∧ ada = False) ≡ F
T F
4
7 indeks = indeks - 1 = 3
8 if (ada = False) ≡ F
T

9 return indeks = 3

 Implementasi Pseudo-code Lain

LINIER-SEARCH1 (A, key) LINIER-SEARCH2 (A, key)
1 𝑎𝑑𝑎 ← False; 1 for 𝑖𝑛𝑑𝑒𝑘𝑠 ← 1 to length[A]
2 for 𝑖𝑛𝑑𝑒𝑘𝑠 ← 1 to length[A] 2 if A[indeks] = key
3 if A[indeks] = key 3 then break;
4 then ada = True; 4 if indeks > length[A]
5 break; 5 then A[indeks] ← key;

6 if ada = False 6 return indeks

7 then A[indeks] ← key;

8 return indeks
 Loop Invariant dan Correctness
 Inisialisasi (initialization)
- Perulangan dimulai dengan nilai 𝑖𝑛𝑑𝑒𝑘𝑠 = 1 dan 𝑎𝑑𝑎 = False.
 Pemeliharaan (maintenance)
- Selama statemen perulangan memeriksa bahwa pernyataan (𝑖𝑛𝑑𝑒𝑘𝑠 ≤ 𝑙𝑒𝑛𝑔𝑡ℎ[A] dan
𝑎𝑑𝑎 = False) bernilai benar.
- Perulangan berlanjut dengan 𝑖𝑛𝑑𝑒𝑘𝑠 = 𝑖𝑛𝑑𝑒𝑘𝑠 + 1.
 Pengehentian (termination)
- Jika key ditemukan A[𝑖𝑛𝑑𝑒𝑘𝑠] = 𝑘𝑒𝑦 maka perulangan berhenti 𝑎𝑑𝑎 = True atau jika
tidak ada lagi data yang bisa dibandingkan 𝑖𝑛𝑑𝑒𝑘𝑠 > 𝑙𝑒𝑛𝑔𝑡ℎ[A].
 Contoh Masalah Lain
 SORTING PROBLEM
- Input : Barisan n bilangan dalam array 𝐴 =< 𝑎1 , 𝑎2 , … , 𝑎𝑛 >
- Output : Permutasi barisan bilangan sedemikian sehingga terurut kembali ke dalam
barisan bilangan 𝐴 =< 𝑎1′ , 𝑎2′ , … , 𝑎𝑛′ >, dimana 𝑎1′ ≤ 𝑎2′ ≤ … ≤ 𝑎𝑛′
 Ide Sederhena
 Mengurutkan seperti kartu trup dengan cara:
- Scanning seluruh kartu dari awal sampai akhir;
- Buat kartu patokan pada saat scanning dan lakukan scanning kartu untuk
membandingkan nilai kartu;
- Tukar kartu jika nilai pada kartu yang ter-scanning lebih kecil dari kartu patokan.
 Algoritma Insertion-Sort
INSERTION-SORT(A)
1 for 𝑗 ← 2 to length[A]
2 𝑘𝑒𝑦 ← 𝐴[𝑗]
3 𝑖 ← 𝑗−1
4 while (𝑖 > 0 ∧ 𝐴[𝑖] > 𝑘𝑒𝑦)
5 𝐴[𝑖 + 1] ← 𝐴[𝑖]
6 𝑖 ← 𝑖−1
7 𝐴[𝑖 + 1] ← 𝑘𝑒𝑦
INGAT BAHWA: Waktu komputasi (running time) algoritma tergantung dari jumlah data yang ada
dalam larik A.

SIMULASI
indeks 1 2 3 4 5
Misalkan:
A= 31 41 59 26 60
Key = Variabel sementara
1 for 𝑗 = 2
a) 𝑘𝑒𝑦 = 𝐴[2] = 41
b) 𝑖 = 𝑗 − 1 = 2 − 1 = 1
31 41
c) while (𝑖 > 0 ∧ 𝐴[1] > 𝑘𝑒𝑦) ≡ F
T F

d) 𝐴[𝑖 + 1] = 𝑘𝑒𝑦 = 41
2 for 𝑗 = 3
a) 𝑘𝑒𝑦 = 𝐴[3] = 59
b) 𝑖 = 𝑗 − 1 = 3 − 1 = 2
41 59
c) while (𝑖 > 0 ∧ 𝐴[2] > 𝑘𝑒𝑦) ≡ F
T F

d) 𝐴[𝑖 + 1] = 𝑘𝑒𝑦 = 59
3 for 𝑗 = 4
a) 𝑘𝑒𝑦 = 𝐴[4] = 26
b) 𝑖 = 𝑗 − 1 = 4 − 1 = 3
59 26
c) while (𝑖 > 0 ∧ 𝐴[3] > 𝑘𝑒𝑦) ≡ T
T T
26 59
c.1. 𝐴[𝑖 + 1] = 𝐴[𝑖] 31 41 59 59 60
c.2. 𝑖 =𝑖−1 =2
41 26
d) while (𝑖 > 0 ∧ 𝐴[2] > 𝑘𝑒𝑦) ≡ T
T T
59 41
d.1. 𝐴[𝑖 + 1] = 𝐴[𝑖] 31 41 41 59 60
d.2. 𝑖 = 𝑖 − 1 = 1
31 26
e) while (𝑖 > 0 ∧ 𝐴[1] > 𝑘𝑒𝑦) ≡ T
T T
41 31
d.1. 𝐴[𝑖 + 1] = 𝐴[𝑖] 31 31 41 59 60
d.2. 𝑖 = 𝑖 − 1 = 0
f) while (𝑖 > 0 ∧ 𝐴[𝑖] > 𝑘𝑒𝑦) ≡ F
F

g) 𝐴[𝑖 + 1] = 𝑘𝑒𝑦 → 𝐴[1] = 26 26 31 41 59 60

4 for 𝑗 = 5
a) 𝑘𝑒𝑦 = 𝐴[5] = 60
b) 𝑖 = 𝑗 − 1 = 5 − 1 = 4
59 60
c) while (𝑖 > 0 ∧ 𝐴[4] > 𝑘𝑒𝑦) ≡ F
T F

d) 𝐴[𝑖 + 1] = 𝑘𝑒𝑦 = 60 26 31 41 59 60
5 for 𝑗 = 6 ≡ F
 Analasis Algoritma
INSERTION-SORT(A) Times T(n)
1 for 𝑗 ← 2 to length[A] 𝑛
2 𝑘𝑒𝑦 ← 𝐴[𝑗] 𝑛−1
3 𝑖 ← 𝑗−1 𝑛−1
4 while (𝑖 > 0 ∧ 𝐴[𝑖] > 𝑘𝑒𝑦) ∑𝑛𝑗=2 𝑡𝑗
5 𝐴[𝑖 + 1] ← 𝐴[𝑖] ∑𝑛𝑗=2(𝑡𝑗 − 1)
6 𝑖 ← 𝑖−1 ∑𝑛𝑗=2(𝑡𝑗 − 1)

7 𝐴[𝑖 + 1] ← 𝑘𝑒𝑦 𝑛−1

Total waktu komputasi (running time) 𝑇(𝑛):
𝑛 𝑛 𝑛

𝑇(𝑛) = 𝑛 + (𝑛 − 1) + (𝑛 − 1) + ∑ 𝑡𝑗 + ∑(𝑡𝑗 − 1) + ∑(𝑡𝑗 − 1) + (𝑛 − 1)

𝑗=2 𝑗=2 𝑗=2
𝑛

= 2𝑛 + 3 ∑ 𝑡𝑗 − 1
𝑗=2

Waktu komputasi tidak hanya tergantung pada jumlah data, tetapi juga tergantung pada
bagaimana barisan input data.
 Kasus terbaik (best case): Input data telah terurut, 𝑡𝑗 = 1
𝑛

𝑇(𝑛) = 2𝑛 + 3 ∑ 1 − 1 = 5𝑛 − 4
𝑗=2

Laju waktu komputasi dalam fungsi linier.

 Kasus terburuk (worst case): Input data terurut terbalik, 𝑡𝑗 = 𝑗
𝑛
3 7
𝑇(𝑛) = 2𝑛 + 3 ∑ 𝑗 − 1 = 𝑛2 + 𝑛 − 4
2 2
𝑗=2

Laju waktu komputasi dalam fungsi kuadratik.

INGAT BAHWA:
𝑛 𝑛 𝑛 𝑛
2
𝑛(𝑛 + 1) 𝑛(𝑛 + 1)
∑1 = 𝑛 , ∑(2𝑗 − 1) = 𝑛 , ∑𝑗 = , ∑𝑗 = −1
2 2
𝑗=1 𝑗=1 𝑗=1 𝑗=2

 Masalah Pencarian Data

 SEARCHING PROBLEM
- Input : Barisan n bilangan asli < 𝑎1 , 𝑎2 , … , 𝑎𝑛 > dalam larik A dan sebuah bilangan key
yang ingin dicari.
- Output : Lokasi key dalam A. Jika key tidak ditemukan di dalam A, maka key akan
ditambahkan sebagai unsur terakhir.
 Contoh: Input barisan bilangan : A = (31, 41, 59, 26, 41, 58) dan key = 26
Algoritma pencarian mengembalikan Output menghasilkan posisi key adalah 4.
 Pencarian Berulang
LOOP-SEARCH(A, key) Times T(n)
1 𝑎𝑑𝑎 ← False 1
2 for 𝑖 ← 1 to length[A] 𝑛+1
3 if A[𝑖] = 𝑘𝑒𝑦 then 𝑛
4 𝑝𝑜𝑠𝑖𝑠𝑖 ← 𝑖 ∑𝑛𝑖=1 𝑡𝑖
5 𝑎𝑑𝑎 ← True ∑𝑛𝑖=1 𝑡𝑖
6 if not(ada) then 1
7 𝑝𝑜𝑠𝑖𝑠𝑖 ← 𝑙𝑒𝑛𝑔𝑡ℎ[A] + 1 s
8 A[𝑝𝑜𝑠𝑖𝑠𝑖] ← 𝑑𝑎𝑡𝑎 s
Total waktu komputasi:
𝑛
𝑇(𝑛) = 2𝑛 + 2 ∑ 𝑡𝑖 + (2𝑠 + 3)
𝑖=1

 Kasus terbaik: Terdapat tepat satu unsur dalam larik A sama dengan key. (Dalam hal ini
∑𝑛𝑖=1 𝑡𝑖 = 0 dan 𝑠 = 1)
𝑛
𝑇(𝑛) = 2𝑛 + 2 ∑ 𝑡𝑖 + (2𝑠 + 3) = 2𝑛 + 5
𝑖=1

 Kasus terburuk: Semua unsur dalam larik A sama dengan key. (Dalam hal ini ∑𝑛𝑖=1 𝑡𝑖 = 𝑛
dan 𝑠 = 0)
𝑛
𝑇(𝑛) = 2𝑛 + 2 ∑ 𝑡𝑖 + (2𝑠 + 3) = 4𝑛 + 3
𝑖=1

 Improvisasi Algoritma
Pencarian dilakukan dengan membagi dua data dan perulangan dilakukan secara bergantian
pada kedua sisi.

n/2 n/2

n/2 n/2

 Pencarian Biseksi (Bagi-Dua)

BISECTION-SEARCH(A, key) Times T(n)
1 𝑎𝑑𝑎 ← False 1
1
2 for 𝑖 ← 1 to [length[A]/2] 2
𝑛 +1
1
3 if A[𝑖] = 𝑘𝑒𝑦 then 2
𝑛
 𝑛
4 𝑝𝑜𝑠𝑖𝑠𝑖 ← 𝑖 2
∑𝑖=1 𝑡𝑖
𝑛
5 𝑎𝑑𝑎 ← True 2
∑𝑖=1 𝑡𝑖
1
6 if A[𝑛 − 𝑖 + 1] = 𝑘𝑒𝑦 then 2
𝑛
𝑛
7 𝑝𝑜𝑠𝑖𝑠𝑖 ← 𝑛 − 𝑖 + 1 2
∑𝑖=1 𝑝𝑖
𝑛
8 𝑎𝑑𝑎 ← True 2
∑𝑖=1 𝑝𝑖
9 if not(ada) then 1
10 𝑝𝑜𝑠𝑖𝑠𝑖 ← 𝑙𝑒𝑛𝑔𝑡ℎ[A] + 1 s
11 A[𝑝𝑜𝑠𝑖𝑠𝑖] ← 𝑑𝑎𝑡𝑎 s
Total waktu komputasi:
𝑛 𝑛
3 2 2
𝑇(𝑛) = 𝑛 + 2 ∑ 𝑡𝑖 + 2 ∑ 𝑝𝑖 + (2𝑠 + 3)
2 𝑖=1 𝑖=1
𝑛
 Kasus terbaik: terdapat satu unsur dalam larik A sama dengan key. (Dalam hal ini ∑𝑖=1
2
𝑡𝑖 =
𝑛
1 , ∑𝑖=1
2
𝑝𝑖 = 1 dan 𝑠 = 0)
𝑛 𝑛
3 2 2 3
𝑇(𝑛) = 𝑛 + 2 ∑ 𝑡𝑖 + 2 ∑ 𝑝𝑖 + (2𝑠 + 3) = 𝑛 + 5
2 𝑖=1 𝑖=1 2
𝑛
𝑛
 Kasus terburuk: Semua unsur dalam larik A sama dengan key. (Dalam hal ini ∑𝑖=1
2
𝑡𝑖 = ,
2
𝑛
𝑛
2
∑𝑖=1 𝑝𝑖 = 2 dan 𝑠 = 0)
𝑛 𝑛
3 2 2 7
𝑇(𝑛) = 𝑛 + 2 ∑ 𝑡𝑖 + 2 ∑ 𝑝𝑖 + (2𝑠 + 3) = 𝑛 + 3
2 𝑖=1 𝑖=1 2
 Ada ide lain yang membuat waktu komputasi (running time) pencarian data menjadi lebih cepat:
1 1 1
 Pengembangan alamiah: Pencarian dipecah menjadi beberapa bagian lagi seperti , , , 𝑑𝑠𝑡.
4 8 16
1 1 1 1
namun pengembangan alamiah hanya mengurangi 2 , 4 , 8 , 16 dari jumlah data n.

 Metode lain yang membuat running time berkurang secara drastis adalah Binary Search Tree.
 Binary Search Tree (BST)
 Struktur data: Prosedur penyimpanan data dalam bentuk tertentu sedemikian sehingga
operasi dasar pada algoritma menjadi lebih efisien atau optimal.
 Contoh untuk masalah pencarian Binary Search Tree yaitu struktur data yang memenuhi sifat:
Kiri(i) ≤ akar(i)
Kanan(i) > akar(i)
 Contoh Binary Search Tree 31 Data (titik)

63

33 87

22 44 76 96

8 27 37 52 67 80 93 98

3 16 25 32 35 43 49 57 65 71 79 85 89 95 97 99

n T(n)
1 1
3 2
7 3
15 4
31 5
63 6
𝑛 = 2𝑇(𝑛) − 1
127 7
255 8
⇓
511 9
1,023 10
𝑇(𝑛) = lg 𝑛 + 1
2,047 11
4,095 12 NOTE:
8,191 13
16,383 14 lg = logaritma basis 2
32,767 15
65,535 16
131,071 17
262,143 18
524,287 19
1,048,575 20