Outline Materi Alpro-2

Outline Materi Alpro-2

Prinsip” Analisa Algoritma Pemrograman Berorientasi Object Swing Exception Handling Collection Thread Operasi File Algoritma Iterasi Algoritma Rekusif Algoritma Matematika Sorting Searching String Searching

Penilaian:

Tugas Harian Kuliah Kuis Project Demo UTS Project Demo UAS vegafar.wordpress.com [email protected]

Prinsip-Prinsip Analisa Algoritma

Alpro-2

Target:

Mahasiswa dapat memperkirakan waktu yang dibutuhkan dalam penerapan sebuah algoritma

Mahasiswa memahami kerangka matematik yang menggambarkan running time

Mahasiswa mengenali beberapa teknik sederhana yang dapat memperbaiki running time

Mahasiswa memahami bahwa suatu permasalahan dapat diselesaikan dengan beberapa algoritma dengan running time yang berbeda-beda

Algoritma ???

Mrk: urutan langkah” yang tepat dan pasti dalam memecahkan suatu

masalah secara logis or set instruksi yang harus diikuti oleh komputer untuk memecahkan masalah

Beberapa masalah dapat diselesaikan dengan algoritma yang bermacam” asal hasilnya sama

Setiap BP punya + - dalam mengimplementasikan algoritma Setiap programer dapat mengimplementasikan algoritma dengan cara

yang berbeda” algoritma dapat dianalisis efisiensi dan kompleksitasnya, dimana

program harus berhenti dalam batas waktu yang wajar (reasonable) Penilaian algoritma didasarkan pada:

Waktu eksekusi (paling utama), d/ mengetahui berapa banyak resource (time & space) yang diperlukan oleh sebuah algoritma

Penggunaan memori/sumber daya Kesederhanaan dan kejelasan algoritma

Analisa Algoritma….What???

Mengukur jumlah sumber daya (time & space) yang diperlukan oleh sebuah algoritma

Waktu yang diperlukan (running time) oleh sebuah algoritma cenderung tergantung pada jumlah input yang diproses

Algoritma tidak terikat pada platform mesin, OS, BP, kualitas kompilator atau bahkan paradigma pemrograman (mis. Procedural vs Object-Oriented)

Analisa Algoritma….How???

Bagaimana menganalisa algoritma? Jumlah waktu yang digunakan bervariasi

tergantung pada kecepatan mesin sistem operasi (multi-tasking) kualitas kompiler BP yang digunakan

Sehingga kurang memberikan gambaran yang tepat tentang algoritma

Analisa Algortima….Kesimpulan Analisa algoritma tidak mudah dilakukan secara pasti hanya diambil:

Kondisi rata-rata (average case) Kondisi terburuk (worst case) Kondisi baik (best case)

Waktu eksekusi dipengaruhi: Jenis data input Jumlah data input Pemilihan instruksi BP

Faktor” yang menyulitkan analisis, disebabkan: Implementasi instruksi oleh BP berbeda” Ketergantungan algoritma terhadap jenis data Ketidakjelasan algoritma yang diimplementasikan

Langkah” analisis algoritma: Menentukan jenis/sifat data input Mengidentifikasi abstract operation dari data input Menganalisis secara matematis untuk menentukan average case, worst case

dan best case

Analisa Algortima….Kesimpulan

Running Time

Untuk input yang sedikit, beberapa fungsi lebih cepat dibandingkan dengan yang lain

Running Time

Untuk input yang besar, beberapa fungsi running-time sangat lambat - tidak berguna

NOTASI Big-Oh/O (1)

Fungsi: Digunakan sebagai bahasa untuk membahas efisiensi

dari sebuah algoritma: log n, linier, n log n, n2, n3, ... digunakan untuk merepresentasikan laju pertumbuhan

(growth rate) Dari hasil run-time, dapat kita buat grafik dari waktu

eksekusi dan jumlah data Mrkfungsi yang berkaitan dengan kelajuan proses daripada

kelajuan pertambahan dataT(n) = O(f(n))if ada konstan c dan no sedemikian rupa thenT(n) ≤ c.f(n) untuk n ≥ no O(f(n)) nilai maksimum dari c.f(n)

c/ If f(n) = 2n2 Then T(n) = O(n2)

If f(n) = 4n2 + 7n + 3 Then T(n) = O(n3)

NOTASI Big-Oh/O (3) c/ program-1

sum=0;for (i=0; i<n; i++)

sum=sum+a[i];Penghitungan eksekusi:sum = 0 dieksekusi 1 kalii = 0 dieksekusi 1 kalii < n diekseklusi n kalii++ dieksekusi n kalisum = sum + a[i] dieksekusi n kali

----------------------2 + 3n kali Jadi T(n) = O(n)

Function Name c Constant log N Logarithmic log2 N Log-squared N Linear N log N N log N N2 Quadratic N3 Cubic 2N Exponential N! Factorial

NOTASI Big-Oh/O (4) c/ program-2

sum=0;for (i=0; i<n; i++)

for (j=0; j<n; j++)sum= sum+a[j];

Penghitungan eksekusi:sum = 0 dieksekusi 1 kalii = 0 dieksekusi 1 kalii < n dieksekusi n kalii++ dieksekusi n kalij = 0 dieksekusi 1 kalij < n dieksekusi n × n kalij++ dieksekusi n × n kalisum = sum + a[ j ] dieksekusi n × n kali

--------------------------- 3 + 2n + 3n2 kali

KLASIFIKASI ALGORITMA (1)

T(n)=c Jika sebagian besar instruksi pada program hanya dieksekusi

constant/ sekali Bersifat konstan, tidak bergantung pada parameter/n data yang

diolah Merupakan algoritma paling ideal

c/ void hitung(){

a=2;b=2;c=a+b;

}


T(n)=O(n) Waktu eksekusinya sebanding/sama dengan jumlah data Setiap data input hanya diolah secara sederhana, c/ untuk

operasi + - x : Kondisi optimal yang dicari dalam membuat algoritma

c/

for (int i=0; i<n; i++)

a[i]=0;


Waktu eksekusi berbading dengan kwadrat jumlah data, m/: Jika n=10 waktu eksekusinya 100 Jika n=20 waktu eksekusinya 400

Biasanya timbul karena setiap data dieksekusi 2 kali, misal dlm nested loop

c/ Algoritma Bublesortfor(int i=0; i<n; i++)

for (int j=0; j<m; j++)a[i,j]=0;

d/ perhitungan: Loop luar dieksekusi n kali Loop dalam dieksekusi m kali Total eksekusi = n × m kali

)()( 2nOnT


Untuk algoritma yang mengolah setiap data input 3x c/ pada nested loop Algoritma semacam ini sebisa mungkin dihindari c/

for (i=0; i<n; i++)

for (j=0; j<n; j++)

for (k=0; k<n; k++)

a[i,j,k]=0;

)()( 3nOnT


T(n)=O(log n) Waktu eksekusi sebanding dengan algoritma dari n-data m/ n-data menjadi 2 kali semula berarti waktu proses

bertambah 1 unit; jika 1000x bertambah 10 unit, jika 1000000x berarti 20 unit

Biasanya untuk algoritma yang memecah masalah besar kedalam sub masalah yang lebih kecil

c/ Algoritma binary search dan algoritma fungsi rekursif T(n)=O(n log n)

Bersifat linier dan logaritmis Untuk algoritma yang memecah masalah besar menjadi

sub-masalah yang lebih kecil dan diselesaikan secara terpisah, kemudian hasilnya digabungkan.

Contoh : Quicksort


Pada implementasinya, algoritma kadang-kadang memiliki Big-Oh yang merupakan kombinasi dari klasifikasi dasar tersebut

Perancangan algoritma yang memiliki Big-Oh baik tetapi rumit tidak selalu menguntungkan apabila jumlah data inputnya hanya sedikit

Nilai Big-Oh adalah nilai worst case, sehingga dalam implementasinya biasanya tidak mencapai nilai setinggi itu

n log n n log n n2 n3

10 3 30 100 1000

100 6 600 10000 100000

1000 9 9000 1000000 1000000

10000 13 130000 100 juta 1 trilyun

100000 16 1600000 10 milyard 100 trilyun

Aturan Algoritma:1. For Loop (perulangan) Waktu eksekusi pada for loop, maksimum sebanyak

waktu eksekusi statement” yang ada di dalam loop dikalikan banyaknya iterasi

c/for (a=0; a<n; a++){

m=a+b;n=c+d;

} Waktu eksekusi = 2 x n kali Jadi T(n) = O(n)

Aturan Algoritma:2. Nested for loop (perulangan bersarang)

Dianalisis dari loop terdalam kemudian keluar Waktu eksekusi total sebuah statement adalah waktu

eksekusi statement tsb dikalikan hasil kali dari banyaknya iterasi semua loop yang ada diluarnya

c/

for(int i=0; i<n; i++)

for (int j=0; j<m; j++)

a[i,j]=0; a[i,j] akan dieksekusi sebanyak (m x n) kali. Jadi T(n) = O(n2)

Aturan Algoritma:3. Consecutive Statement (statement yang berurutan)

Untuk statement yang berurutan, waktu eksekusinya adalah jml dari masing-masing statement

Berdasarkan pengertian Big-OH, hal tsb akan diambil nilai yang terbesar

c/ (1) for(int k=0; k<10; k++)(2) x[k]=0;(3) for(int i=0; i<n; i++)(4) for (int j=0; j<m; j++)(5) a[i,j]=0;

Jadi T(n) = T1(n) + T2(n)+T3(n) = O(n3)

)()( 21 nOnT

)()( 22 nOnT

Aturan Algoritma:

4. if else Total waktu eksekusi adalah waktu test ditambah waktu yang

terbesar dari eksekusi Statemen1 atau Statemen2 c/

(1) if (a<10)(2) {(3) m=a+b;(4) n=c+d;(5) }(6) else(7) {(8) for (i=0; i<10; i++)(9) x=x+i;(10) } u/ baris 1-10 dengan rentang waktu tes=1-10 Jadi total waktu eksekusi adalah 1 + 10 = 11 Jadi T(n) = O(n)

Big-Oh Rules (1)

Ekspresi matematika untuk menyatakan tingkat laju pertumbuhan relatif: DEFINITION: (Big-Oh) T(N) = O(F(N)) jika ada

konstan positif c dan N0 sehingga T(N) c F(N)

untuk N N0.

DEFINITION: (Big-Omega) T(N) = (F(N)) jika ada konstan c dan N0 sehingga T(N) c F(N)

untuk N N0

DEFINITION: (Big-Theta) T(N) = (F(N)) jika dan hanya jika T(N) = O(F(N)) dan T(N) = (F(N)).

DEFINITION: (Little-Oh) T(N) = o(F(N)) jika dan hanya jika T(N) = O(F(N)) dan T(N) (F(N)).

Big-Oh Rules (2) Arti dari beberapa fungsi tingkat laju.

Jika ada lebih dari satu parameter, maka aturan tersebut berlaku untuk setiap parameter. 4 n log(m) + 50 n2 + 500 m + 1853

O(n log(m) + n2 + m) 4 m log(m) + 50 n2 + 500 m + 853

O(m log(m) + n2)

T(N) = O(F(N)) Growth of T(N) is growth of F(N)T(N) = (F(N)) Growth of T(N) is growth of F(N)T(N) = (F(N)) Growth of T(N) is = growth of F(N)T(N) = o(F(N)) Growth of T(N) is growth of F(N)

Panduan Running Time (detik)

Contoh Algoritma Mencari dua titik yang memiliki jarak terpendek dalam sebuah

bidang koordinat XY Masalah dalam komputer grafis Algoritma brute force:

hitung jarak dari semua pasangan titik cari jarak yang terpendek

Jika jumlah titik adalah n, maka jumlah semua pasangan n*(n-1)/ 2 Orde-nya: O(n2) – kuadratik Ada solusi yang O(n log n) bahkan O(n) dengan cara algoritma lain

Tentukan apakah ada tiga titik dalam sebuah bidang yang segaris (colinier) Algoritma brute force:

periksa semua tripel titik yang terdiri dari 3 titik Jumlah pasangan: n * (n - 1) * (n - 2) / 6 Orde-nya: O(n3) - kubik. Sangat tidak berguna untuk 10.000 titik Ada algoritma yang kuadratik

04/21/23 29

Studi Kasus

Mengamati sebuah masalah dengan beberapa solusi

Masalah Maximum Contiguous Subsequence Sum Diberikan (angka integer negatif A1, A2, …, AN)

cari nilai maksimum dari (Ai + Ai+1 + …+ Aj ) maximum contiguous subsequence sum=0

jika semua integer adalah negatif

Brute Force Algorithma (1) Algoritma:

Hitung jumlah dari semua sub-sequence yang mungkin

Cari nilai maksimumnya Contoh:

jumlah subsequence (start, end)

• (0, 0), (0,1), (0,2), …, (0,5)• (1,1), (1,2), …, (1, 5)• …• (5,5)

04/21/23 31

Brute Force Algorithm (2)

public static int maxSubSum1( int [] A ) { int maxSum = 0; for(int ii = 0; ii < A.length; ii++) { for( int jj = ii; jj < A.length; jj++) { int thisSum= 0; for(int kk = ii; kk <= jj; kk++) thisSum += A[kk]; if( thisSum > maxSum ) maxSum = thisSum; } } return maxSum ; }

•sum [ii, jj] = sum [ii, jj – 1] + Ajj

04/21/23 32

Brute Force Algorithma (3) Analisa:

Iterasi (kk) sebanyak N dalam iterasi (jj) sebanyak N dalam iterasi (ii) sebanyak N artinya: O(N3), atau algoritma kubik.Slight over-estimate yang dihasilkan dari perhitungan iterasi yang kurang dari N adalah tidak terlalu penting (kk <= jj)

Running Time:Untuk N = 100, waktu sebenarnya adalah 0.47 detik pada sebuah komputerDapat menggunakan informasi tersebut, untuk memperkirakan waktu untuk input yang lebih besar:

T(N) = cN 3T(10N) = c(10N)3 = 1000cN 3 = 1000T(N)

Ukuran input meningkat dengan kelipatan 10 kali, yang artinya meningkatkan running time dengan kelipatan 1000 kali. Untuk N = 1000, perkiraan waktu 470 detik. (waktu sebenarnya 449 detik).Untuk N = 10.000, perkiraan waktu 449000 detik (6 hari).

04/21/23 33

Brute Force Algorithma (4) Bagaimana memperbaikinya?

Membuang sebuah iterasi; Tidak selalu bisa Dalam contoh sebelumnya dimungkinkan:

iterasi paling dalam (kk) tidak diperlukan karena informasi nya terbuang

Nilai thisSum untuk nilai jj selanjutnya dapat dengan mudah diperoleh dari nilai thisSum yang sebelumnya: Yang diperlukan: Aii + A ii+1 + … + A jj-1 + Ajj

Yang telah dihitung: Aii +A ii+1 + …+ A jj-1

Yang dibutuhkan adalah yang telah dihitung + Ajj

Dengan kata lain:

• sum [ii, jj] = sum [ii, jj – 1] + Ajj

Contoh Algoritma Brute Force

1. Menghitung an (a > 0, n adalah bilangan bulat tak-negatif) an = a x a x … x a (n kali) , jika n > 0 = 1 , jika n = 0

Algoritma: kalikan 1 dengan a sebanyak n kali

2. Menghitung n! (n bilangan bulat tak-negatif)

n! = 1 × 2 × 3 × … × n , jika n > 0

= 1 , jika n = 0

Algoritma:

kalikan n buah bilangan, yaitu 1, 2, 3, …, n, bersama-sama



3. Mengalikan dua buah matrik yang berukuran n × n

Misalkan C = A × B dan elemen-elemen matrik dinyatakan sebagai cij, aij, dan bij

Deklarasi i, j, k, n: integer input A, B: matrik output C: matriksAlgoritmahitung setiap elemen hasil perkalian satu per satu, dengan cara mengalikan dua vektor yang panjangnya n. for (i=0; i<n; i++) for (j=0; j<n; j++) C[i,j]=0 for (k=0; k<n; k++) C[i,j]=C[i,j]+A[i,k]*B[k,j]

n

kkjiknjinjijiijbabababac

12211

Contoh Algoritma Brute Force4. Menemukan semua faktor dari bilangan bulat n selain dari 1

dan n itu sendiri.

Definisi: Bilangan bulat a adalah faktor dari bilangan bulat b jika a habis membagi b

Deklarasik:integerinput n:integer

Algoritmak=0ketemu=falsefor (k=2; k<n-1; k++) if n mod k=0 then

s.o.p(k)

Contoh Algoritma Brute Force5. Mencari elemen terbesar atau terkecil

Persoalan: Diberikan sebuah himpunan yang beranggotakan n buah bilangan bulat. Bilangan-bilangan bulat tersebut dinyatakan sebagai a1, a2, …, an. Carilah elemen terbesar di dalam himpunan tersebutDeklarasi

k:integerinput a1,a2….an:integeroutput maks:integer

Algoritmamaks=a1;for (k=2; k<n; k++) if a[k]>maks then

maks=a[k];Kompleksitas algoritma ini adalah O(n)


6. Sequential Search

Persoalan: Diberikan n buah bilangan bulat yang dinyatakan sebagai a1, a2, …, an. Carilah apakah x terdapat di dalam himpunan bilangan bulat tersebut. Jika x ditemukan, maka lokasi (indeks) elemen yang bernilai x disimpan di dalam peubah idx. Jika x tidak terdapat di dalam himpunan tersebut, maka idx diisi dengan nilai 0

Deklarasik,x:integerinput a1,a2….an:integeroutput idx:integer

Algoritma k=1 while(k<n)and(a[k]!=x) do k=k+1 endwhile if a[k]=x then idx=k else idx=0 endifKompleksitas algoritma ini adalah O(n)


7. Bubble Sort

• metode yang paling bagus dalam memecahkan masalah pengurutan algoritma bubble sort

• Alur mengurutkan tabel L[1…n], sehingga terurut naik; dengan inputan (tabel L yang sudah didefinisikan nilai”nya); output (tabel L yang terurut naik L[1]<=L[2]…<=L[n]Deklarasi

i,k,n,temp:integerinput/output tabel L: integer

Algoritmafor (i=1; i<n-1; i++)

for (k=n; k<n-1; i++) if L[k]<L[k-1] then temp=L[k] L[k]=L[k-1]

L[k-1]=tempKompleksitas algoritma ini adalah O(n2)


8. Menentukan bilangan prima

Persoalan: Diberikan sebuah bilangan bilangan bulat positif. Ujilah apakah bilangan tersebut merupakan bilangan prima atau bukan.

Next Lanjut:

akan kita terapkan di materi tentang searching; Sorting & Rekursif

04/21/23 42

The Better Algorithma (1) Analisa:

Dengan logika yang sama, Saat ini running time adalah quadratic, or O(N2)Perkirakan waktu eksekusi untuk input berukuran ribuan. Algoritma ini masih dapat digunakan untuk ukuran input 10 ribu Running Time:Untuk N = 100, waktu sebenarnya adalah 0.011 detik pada sebuah komputerPerkirakan waktu sebenarnya untuk input lebih besar:

T(N) = cN 2

T(10N) = c(10N)2 = 100cN 2 = 100T(N)Input diperbesar dengan kelipatan 10 artinya running time akan membesar dengan kelipatan 100

u/ N = 1000, perkiraan running time 1.11 detik (waktu sebenarnya 1.12 detik)u/ N = 10,000, perkiraan 111 detik (= actual)

04/21/23 43

The Better Algorithma (2) public static int maxSubSum2( int [ ] A ) { int maxSum = 0; for( int ii = 0; ii < A.length; ii++ ) { int thisSum = 0; for( int jj = ii; jj < A.length; jj++ ) { thisSum += A[jj]; if( thisSum > maxSum ) maxSum = thisSum; } } return maxSum ; }

04/21/23 44

Algoritma Rekursif (1) Gunakan pendekatan divide-and-conquer :

Membagi (divide) permasalahan ke dalam bagian yang lebih kecil

Menyelesaikan (conquer) masalah per bagian secara recursive

Menggabung penyelesaian per bagian menjadi solusi masalah awal

Urutan dengan nilai jumlah terbesar kemungkinan berada pada: terletak di setengah input awal terletak di setengah input akhir. berawal disetengan input awal dan berakhir di setengah

input akhir. Hitung ketiga kemungkinan tersebut. Cari yang lebih

besar. Kedua kemungkinan pertama dapat dengan mudah

dihitung secara rekursif.

04/21/23 45

Algoritma Rekursif (2)

dapat dilakukan dengan dua iterasi; lihat program

kemungkinan ketika berasal dari penjumlahan dua bagian, bagian pertama berawal pada setengah bagian input pertama berakhir di tengah. Bagian kedua berasal dari urutan index setengah +1 hingga setengah bagian input akhir.bagian pertama gunakan iterasi dari kanan-ke-kiri (right-to-left) mulai dari element terakhir pada setengah input awal.bagian kedua, gunakan iterasi dari kiri-ke-kanan, (left-to-right) mulai dari awal setengah input akhir.

04/21/23 46


Pastikan dalam rekursif program anda ada base case untuk mengatasi zero-element arrays.

Gunakan method “driver” yang public (method rekursif dibuat private)

Aturan Rekursif : Memiliki base case Membuat progress menuju ke base case Asumsikan bahwa panggilan rekursif bekerja

dengan baik. Hindari menghitung sebuah penyelesaian

dua kali.


private int maxSumRec (int[] a, int left, int right) { int center = (left + right) / 2; if(left == right) { // Base case return a[left] > 0 ? a[left] : 0; } int maxLeftSum = maxSumRec (a, left, center);

int maxRightSum = maxSumRec (a, center+1, right); for(int ii = center; ii >= left; ii--) {

leftBorderSum += a[ii]; if(leftBorderSum > maxLeftBorderSum) maxLeftBorderSum = leftBorderSum; }

4 -3 5 -2 -1 2 6 -24* 0 3 -2 -1 1 7* 5

Tengah-tengah


for(int jj = center + 1; jj <= right; jj++) { rightBorderSum += a[jj]; if(rightBorderSum > maxRightBorderSum) maxRightBorderSum = rightBorderSum; } return max3 (maxLeftSum, maxRightSum, maxLeftBorderSum + maxRightBorderSum);}// publicly visible routine (a.k.a driver function)public int maxSubSum (int [] a) { return maxSumRec (a, 0, a.length-1);}

04/21/23 49

Algoritma Rekursif (6)Analisa

Misalkan T( N ) adalah waktu untuk menyelesaikan masalah dengan ukuran input N.

maka T( 1 ) = 1 (1 adalah quantum time unit ketika memproses base case; ingat konstanta tidak terlalu penting. ).

T( N ) = 2 T( N / 2 ) + N Dua buah pemanggilan rekursif, masing-masing

berukuran N / 2. Waktu yang dibutuhkan untuk menyelesaikan masing-masing-nya adalah T( N / 2 )

Kasus ketiga membutuhkan O( N ) .

04/21/23 50

Bottom Line Algoritma

T(1) = 1 = 1 * 1T(2) = 2 * T(1) + 2 = 4 = 2 * 2T(4) = 2 * T(2) + 4 = 12 = 4 * 3T(8) = 2 * T(4) + 8 = 32 = 8 * 4T(16) = 2 * T(8) + 16 = 80 = 16 * 5T(32) = 2 * T(16) + 32 = 192 = 32 * 6T(64) = 2 * T(32) + 64 = 448 = 64 * 7

T(N) = N(1 + log N) = N + N log N = O(N log N)

04/21/23 51

Bottom Line Algoritma Setiap algoritma rekursif yang menyelesaikankan

permasalahan dengan membagi dua permasalahan kemudian melakukan proses linear (menggabung atau memecah) akan selalu O( N log N ) karena analisa yang sama tetap berlaku

Algoritma yang O( N log N ) adalah jauh lebih baik dibanding quadratic

Tapi masih belum lebih baik dibanding O( N ), namun tidak terlalu jauh berbeda

04/21/23 52

Algoritma linear (1)

Algoritma Linear merupakan yang terbaik. Ingat: linear artinya O( N ). Running time yang linear selalu sebanding

dengan ukuran input. Sulit untuk membuat algoritma yang lebih baik dari linear (kecuali ada rumusan tertentu).

Jika input membesar dengan kelipatan 10, maka running time juga hanya akan membesar dengan kelipatan yang sama.

Algoritma linear (2)

Ai,j adalah kumpulan bilangan mulai dari

urutan i hingga urutan j.

Si,j adalah dari kumpulan bilangan tersebut.

Theorema: Untuk Ai,j dengan Si,j < 0. Jika q >

j, maka Ai,q bukanlah deretan terurut yang

terbesar. Bukti:

Si,q = Si,j + Sj+1,q

Si,j < 0 Si,q < Sj+1,q

Algoritma Linear (3)program1static public int maximumSubSequenceSum3 (int a[]) { int maxSum = 0; int thisSum = 0; for (int jj = 0; jj < a.length; jj++) { thisSum += a[jj]; if (thisSum > maxSum) { maxSum = thisSum; } else if (thisSum < 0) { thisSum = 0; } } return maxSum;}

Algoritma Linear (3) program2static public int

maximumSubSequenceSum3b (int a[])

{

int thisSum = 0, maxSum = 0;

for (int ii = 0; ii < a.length; ii++) {

thisSum = Max(0, a[ii] + thisSum);

maxSum = Max(thisSum, maxSum);

}

return maxSum;

}

04/21/23 56

Algoritma Logaritme Definisi Formal

Untuk setiap B, N > 0, logB N = K, if B K = N. Jika (base) B diabaikan, maka default-nya adalah 2 dalam

konteks ilmu komputer (binary representation). c/ log 32 = 5 (karena 25 = 32); log 1024 = 10; log 1048576

= 20; log 1 milyard = sekitar 30 logaritme berkembang jauh lebih lambat dari N dan

lebih lambat dari akar kuadrat dari N. Sebuah algoritma adalah O( log N ) jika

membutuhkan waktu konstan untuk membagi input permasalahan dan mengerjakan masing-masing-nya secara rekursif. (biasanya 1/2).

Penjelasan: Akan terjadi sebanyak log N dari proses konstan tersebut.

04/21/23 57

Contoh Algoritma Logaritme

Mencari bits dalam binary number Berapa banyak bits dibutuhkan untuk

merepresentasikan bilangan bulat? perulangan

Mulai dari X = 1, berapa kali X harus dikalikan dua agar mendekati nilai N?

Mulai dari X = N, jika N dibagi dua terus menerus, berapa kali iterasi agar membuat N lebih kecil atau sama dengan 1 (Halving rounds up).

04/21/23 58

Linear Search

Bila diberikan sebuah bilangan bulat X dan sebuah array A, kembalikan posisi X dalam A atau sebuah tanda bila tidak ada X dalam A. Jika X muncul lebih dari sekali, kembalikan posisi manapun. Array A tidak perlu diubah.

Jika array input tidak terurut, solusinya adalah menggunakan linear search. Running times: pencarian tidak berhasil: O( N ); setiap element

diperiksa pencarian berhasil:

• Worst case: O( N ); setiap element diperiksa• Average case: O( N ); setengah bagian

diperiksa

04/21/23 59

Binary Search (1)

Lihat bilangan ditengah (asumsi array terurut dari kiri ke kanan) Kasus 1: Jika X lebih kecil dari bilangan

ditengah, maka hanya perlu lihat sub array bagian kiri.

Kasus 2: Jika X lebih besar dari bilangan ditengah, maka hanya perlu lihat sub array bagian kanan

Kasus 3: Jika X sama dengan bilangan ditengah, maka selesai.

Base Case: Jika input sub array kosong, X tidak ditemukan.

Binary Search (2)public static int binarySearch (Comparable [ ] a, Comparable x ) throws ItemNotFound{ int low = 0; int high = a.length - 1; int mid;

while( low <= high ) { mid = (low + high) / 2; if (a[mid].compareTo (x) < 0) { low = mid + 1; } else if (a[mid].compareTo (x) > 0) { high = mid - 1; } else { return mid; } } throw new ItemNotFound( "BinarySearch fails" );}

04/21/23 61

Binary Search (3)

Dapat melakukan satu perbandingan tiap iterasi dari pada dua iterasi dengan cara menggantikan base case: Save the value returned by a[mid].compareTo (x)

Average case dan worst case dalam algoritma hasil revisi adalah sama : 1 + log N perbandingan (dibulatkan). Contoh: If N = 1,000,000, maka 20 bilangan dibandingkan.

Sequential search akan lebih banyak 25,000 kali dalam kondisi rata-rata (average case).

Tugas:

Int select (int a[], int k, int n){

int I, j, mini, tmp;for (i=0; i<k; i++){

mini=i;for (j=i+1; j<n; j++){

if (a[j]<a[mini])mini=j;

temp=a[i];a[i]=a[mini];a[mini]=tmp;

}return a[k-1];

}}

Outline Materi Alpro-2

Documents

Transcript of Outline Materi Alpro-2