1 / 62

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

kordell
Download Presentation

Outline Materi Alpro-2

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. 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

  2. Penilaian: • Tugas Harian Kuliah • Kuis • Project Demo UTS • Project Demo UAS • vegafar.wordpress.com • avv.vega81@yahoo.com

  3. Prinsip-Prinsip Analisa Algoritma Alpro-2

  4. 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

  5. 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

  6. 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)

  7. 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

  8. 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

  9. Analisa Algortima….Kesimpulan

  10. Running Time • Untuk input yang sedikit, beberapa fungsi lebih cepat dibandingkan dengan yang lain

  11. Running Time • Untuk input yang besar, beberapa fungsi running-time sangat lambat - tidak berguna

  12. 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 • Mrkfungsi yang berkaitan dengan kelajuan proses daripada kelajuan pertambahan dataT(n) = O(f(n)) if ada konstan c dan no sedemikian rupa then T(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)

  13. 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 kali i = 0 dieksekusi 1 kali i < n diekseklusi n kali i++ dieksekusi n kali sum = sum + a[i] dieksekusi n kali ---------------------- 2 + 3n kali Jadi T(n) = O(n)

  14. 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 kali i = 0 dieksekusi 1 kali i < n dieksekusi n kali i++ dieksekusi n kali j = 0 dieksekusi 1 kali j < n dieksekusi n × n kali j++ dieksekusi n × n kali sum = sum + a[ j ] dieksekusi n × n kali --------------------------- 3 + 2n + 3n2 kali

  15. 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; }

  16. KLASIFIKASI ALGORITMA (2) • 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;

  17. KLASIFIKASI ALGORITMA (3) • 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 Bublesort for(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

  18. KLASIFIKASI ALGORITMA (5) • 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;

  19. KLASIFIKASI ALGORITMA (4) • 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

  20. KLASIFIKASI ALGORITMA (6) • 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

  21. 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)

  22. 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)

  23. 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)

  24. 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)

  25. 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 danN0 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)).

  26. 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)‏

  27. Panduan Running Time (detik)

  28. 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

  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

  30. 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)‏

  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

  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 komputer • Dapat menggunakan informasi tersebut, untuk memperkirakan waktu untuk input yang lebih besar: • T(N) = cN 3 • T(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).

  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 thisSumyang 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

  34. 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

  35. Contoh Algoritma Brute Force 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

  36. Contoh Algoritma Brute Force 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: matriks Algoritma hitung 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]

  37. 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 Deklarasi k:integer input n:integer Algoritma k=0 ketemu=false for (k=2; k<n-1; k++) if n mod k=0 then s.o.p(k) Contoh Algoritma Brute Force

  38. 5. 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 tersebut Deklarasi k:integer input a1,a2….an:integer output maks:integer Algoritma maks=a1; for (k=2; k<n; k++) if a[k]>maks then maks=a[k]; Kompleksitas algoritma ini adalah O(n) Contoh Algoritma Brute Force

  39. 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 Deklarasi k,x:integer input a1,a2….an:integer output idx:integer Contoh Algoritma Brute Force 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 endif Kompleksitas algoritma ini adalah O(n)

  40. 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:integer input/output tabel L: integer Algoritma for (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]=temp Kompleksitas algoritma ini adalah O(n2) Contoh Algoritma Brute Force

  41. 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 Contoh Algoritma Brute Force

  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 komputer • Perkirakan 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)

  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 ; }

  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.

  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.

  46. Algoritma Rekursif (3) • 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.

  47. Tengah-tengah Algoritma Rekursif (4) 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; }

  48. Algoritma Rekursif (5) 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); }

  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 ) .

  50. Bottom Line Algoritma T(1) = 1 = 1 * 1 T(2) = 2 * T(1) + 2 = 4 = 2 * 2 T(4) = 2 * T(2) + 4 = 12 = 4 * 3 T(8) = 2 * T(4) + 8 = 32 = 8 * 4 T(16) = 2 * T(8) + 16 = 80 = 16 * 5 T(32) = 2 * T(16) + 32 = 192 = 32 * 6 T(64) = 2 * T(32) + 64 = 448 = 64 * 7 T(N) = N(1 + log N) = N + N log N = O(N log N)‏

More Related