1 / 25

Analyzing Control Structures in Algorithms: Sequencing and Loops

This analysis explores the control structures within algorithms, focusing on sequencing and loops. It discusses the time complexity of executing tasks sequentially (P1 followed by P2) and establishes the sequencing rule as the sum of individual execution times. The significance of the 'for' loop is emphasized, along with its implications for performance and potential pitfalls. Additionally, recursive functions and their complexities are analyzed, illustrating how different structures impact computation time, especially in recursive calls. We conclude with the evaluation of while loops and their complexities.

snow
Download Presentation

Analyzing Control Structures in Algorithms: Sequencing and Loops

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. Analysis of Algorithm KULIAH #2

  2. Analysing Control Structure • SEQUENCING, misal P1 dan P2 : dua bagian algoritma (bisa single instruction atau complicated subalgorithms). Misal t1 dan t2 masing-masing waktu yang diperlukan oleh P1 dan P2. • SEQUENCING RULE : waktu yang diperlukan untuk compute “P1; P2” (P1 kemudian P2) adalah t1+t2. Dengan “maximum rule”, waktunya dalam Θ(max(t1,t2)). • Kemungkinan : parameter yang mengendalikan t2 tergantung pada hasil computation yang dilakukan oleh P1. Sehingga, analysis “P1; P2” tidak selalu bisa dilakukan dengan menganggap P1 dan P2 secara independent.

  3. Analysing Control Structure (1) • “FOR” LOOP, perhatikan loop for i  1 to m doP(i) (convention : untuk m=0 tidak “error”, hanya statemen terkontrol P(i) sama sekali tidak dieksekusi). • Misal size instance n, P(i) tidak benar-benar tergantung pada i, t waktu untuk compute P(i). • Maka total waktu yang diperlukan loop adalah l=mt. (kemungkinan ada “pitfall”, karena tidak memperhitungkan waktu yang diperlukan untuk “loop control”.)

  4. Analysing Control Structure (2) • “for loop”, merupakan “shorthand” untuk i  1 while i  m do P(i) i  i+1 • Misal c : upper bound on the time requeired by each operation, maka l (t+3c)m + 2c = mt +3cm + 2c. • Jika c bisa diabaikan dibanding t, maka secara kasar l =mt (kecuali jika m=0).

  5. Analysing Control Structure (3) • Analysis “for loop”. Jika t(i) yang diperlukan oleh P(i) berubah sebagai fungsi i. (umumnya, waktu yang diperlukan oleh P(i) bisa tergantung tidak hanya pada i, juga instance size n atau bahkan instance itu sendiri). • Jika waktu untuk “loop control” diabaikan, selama m1, maka loop yang sama fori  1tomdoP(i) akan memerlukan waktu : t(1) + t(2) + … + t(m).

  6. Analysing Control Structure (4) • Perhatikan algoritma functionFibIter(n) i1; j0 for k1 to n do ji+j ij-I return j • Instruksi di dalam “loop” membutuhkan waktu konstan, misal terbatas atas oleh suatu konstan c. Dengan mengabaikan waktu untuk “loop control”, maka waktu akan terbatas atas oleh nc. • Karena instruksi sebelum dan sesudah “loop” diabaikan, maka algoritma memerlukan waktu dalam O(n).

  7. Analysing Control Structure (5) • Dengan Moivre’s formula : ukuran fk berada dalam Θ(k). Sehingga, iterasi ke-k memerlukan waktu Θ(k-1) + Θ(k), atau sama dengan Θ(k). • Misal c : konstan sedemikian hingga waktu ini terbatas atas oleh ck untuk semua k1. • Jika waktu untuk “loop control”, instruksi sebelum dan sesudah “loop” diabaikan, maka waktu yang dibutuhkan algoritma terbatas atas oleh k=1..n ck = c[n(n+1)/2]  O(n2). • Alasan serupa menghasilkan (n2), sehingga waktu yang dibutuhkan algoritma dalam Θ(n2)

  8. Analysing Control Structure (6) • Ada perbedaan besar, antara analysis FibRec yang memperhitungkan operasi aritmatik sebagai “unit cost” dengan yang tidak memperhatikannya. • Analysis “for loop” yang mulainya selain dari 1, bertambah dengan pertambahan lebih besar. Misal, for i5 to m step 2 do P(i) • Untuk m3, P(i) akan dieksekusi sebanyak ((m-5)2) + 1 kali.

  9. Analysing Control Structure (7) • RECURSIVE CALL, perhatikan algoritma FibRec berikut functionFibRec(n) if n<2 then returnn elsereturnFibRec(n-1)+FibRec(n-2) • Misal T(n) : waktu untuk “call on” FibRec(n). • Jika n<2, algoritma hanya mengembalikan n, yang memerlukan waktu konstan a. • Jika n2, kebanyakan kerja dilakukan untuk dua “recursive calls”, yang masing-masing memerlukan waktu T(n-1) dan T(n-2).

  10. Analysing Control Structure (8) • Ditambah satu addition fn-1 dan fn-2(nilai-nilai kembalian oleh “recursive calls”), “recursion control”, dan test ”if n < 2”. • Misal h(n) : kerja yang melibatkan operasi-operasi di atas. Maka dengan definisi T(n) dan h(n) akan didapat rekursi berikut T(n) = a, jika n=0 atau n=1 T(n) = T(n-1) + T(n-2) + h(n), jika n=2,3,…

  11. Analysing Control Structure (9) • WHILE and REPEAT LOOPs, lebih sulit untuk dianalisa dibanding dengan FOR LOOP. Perhatikan algoritma berikut functionBin_Search(T[1..n],x) i1; jn while i<j do {T[i]xT[j]} k(i+j)2 case x<T[k] : jk-1 x=T[k] : i, jk x>T[k] : ik+1 return i • Misal dl : nilai j-i+1 di akhir perjalanan ke-l seputar loop untuk l 1 dan misal d0=n. Karena dl-1 nilai j-i+1 sebelum mulai iterasi ke-l, maka dl  dl-1 / 2 ntuk semua l  1. Dengan induksi matematika maka didapat dl n / 2l.

  12. Analysing Control Structure (10) • Loop terminate ketika d1, yang terjadi ketika l = lg n. Jadi loop akan dimasuki paling banyak lg n kali. Karena masing-masing perjalanan seputar loop memakan waktu konstan, maka “binary search” memakan waktu dalam O(log n). • Alasan serupa menghasilkan batas bawah (log n), sehingga binary search memakan waktu Θ(log n).

  13. Using a Barometer • Barometer instruction : instruction yang dieksekusi paling sedikit sesering instruction lain dalam algoritma. • Ketika algoritma melibatkan beberapa “nested loops”, maka setiap instruction dari “innermost loop” biasanya bisa digunakan sebagai “barometer”.

  14. Supplementary Examples • SELECTION SORT, perhatikan procedure select(T[1..n]) for i1 to n-1 do minjI; minxT[i] for ji+1 to n do if T[j]<minx then minjj minxT[j] T[minj]T[i] T[i]minx

  15. Supplementary Examples (1) • SELECTION SORT, waktu yang diperlukan oleh masing-masing putaran “inner loop” tidak konstan – khususnya jika T[j]<minx – tapi terbatas atas oleh suatu konstanta c. Untuk masing-masing i, instruksi dalam “inner loop” dieksekusi n-(i+1)+1=n-i kali. Sehingga, waktu yang diperlukan oleh “inner loop” adalah t(i)  (n-i)c. Waktu yang diperlukan putaran ke-i di “outer loop” terbatas atas oleh b+t(i) untuk konstanta b yang tepat.

  16. Supplementary Examples (2) • SELECTION SORT, Sehingga, total waktu yang dihabiskan algoritma terbatas atas oleh ½ cn2 + (b – ½ c)n– b. Atau berada dalam O(n2), secara serupa dalam (n2). Jadi berada dalam Θ(n2). • Jika “innermost test – ifT[j]<minx” sebagai barometer, dan menghitung banyaknya kali test tersebut dieksekusi. • Yaitu, i=1..n-1 j=i+1..n 1 = n(n-1)/2

  17. Supplementary Examples (3) • INSERTION SORT, perhatikan procedureinsert(T[1..n]) for i2 to n do xT[i]; ji-1 while i>0and x<T[j] do T[j+1]T[j] jj-1 T[j+1]x • Barometer : banyaknya kali “while loop condition” ditest.

  18. Supplementary Examples (4) • Asumsi i fixed, x = T[i]. • Worse case muncul ketika x < T[j] untuk setiap j antara 1 dan i-1, karena harus membandingkan x dengan T[i-1], T[i-2], …, T[1] sebelum meninggalkan loop “while”. Sehingga, “while loop test” dikerjakan i kali. • Worse case terjadi untuk setiap nilai i dari 2 sampai n. • Sehingga “barometer test” dikerjakan dalam i=2..n i = n(n+1)/2 – 1 kali.

  19. Supplementary Examples (4) • EUCLID’S ALGORITHM, perhatikan functionEuclid(m,n) whilem>0do tm mn mod m nt returnn • Untuk setiap dua bilangan bulat m dan n, dengan nm, maka berlaku nmodm < n/2.

  20. Supplementary Examples (5) • EUCLID’S ALGORITHM, • Jika m>n/2, maka 1n/m<2, sehingga nm=1, yang berakibat bahwa n mod m = n-m(nm) = n-m < n-n/2 = n/2. • Jika mn/2, maka n mod m <m n/2. • Dengan tanpa mengurangi generality, asumsikan nm (jika n<m, putaran pertama loop akan swap m dan n. Karena n mod m = n ketika n < m).

  21. Supplementary Examples (6) • Kondisi di atas, dipertahankan di masing-masing loop, karena nmodm tidak pernah lebih dari m. • Total waktu yang digunakan algoritma adalah dalam order banyaknya putaran loop. Misal # of trips around the loop terbatas atas oleh function of n. • Apa yang terjadi dengan m dan n setelah putaran loop kedua (misal, algoritma belum berhenti).

  22. Supplementary Examples (7) • Misal m0dan n0nilai-nilai awal parameter, setelah putaran pertama m menjadi n0modm0. Setelah putaran ke-2, n mengambil nilai n0mod m0. Sehingga n menjadi < n0/2, dengan kata lain nilai n paling tidak menjadi separoh setelah putaran ke-2. Akan tetapi, masih berlaku nm sehingga argumentasi serupa masih diterapkan lagi. • Kesimpulan : loop akan dimasuki secara kasar paling banyak 2 lg n kali.

  23. Supplementary Examples (8) • THE TOWERS OF HANOI, contoh analisa “recursive algorithm”. • Generalisasi permasalahan, an arbitrary number n of rings. • Solusi : untuk memindahkan m rings yang lebih kecil dari tiang i ke tiang j, pertama-tama dipindahkan m-1 rings yang lebih kecil dari tiang k ke tiang j. (Ada tiga buah tiang (rod) i, j, dan k).

  24. Supplementary Examples (9) • THE TOWERS OF HANOI, perhatikan procedureHanoi(m,i,j) {memindah m smallest rings dari tiang i ke tiang j} if m>0then Hanoi(m-1,i,6-i-j) write i “” j Hanoi(m-1,6-i-j,j) • Untuk menganalisa waktu eksekusi algoritma di atas, instruksi write digunakan sebagai “barometer”.

  25. Supplementary Examples (10) • THE TOWERS OF HANOI, • Misal t(m) : # of times call ofHanoi(m,.,.) dieksekusi. Dengan pengamatan terhadap algoritma, maka t(m) = 0, jika m=0 t(m) = 2t(m-1) + 1, jika m>0 • Selanjutnya bisa diperlihatkan bahwa t(m) = 2m – 1.

More Related