Analysis of Algorithm · 2019-05-17 · Koefisien Leading Term • Misal dua algoritma memiliki kompleksitas waktu dari leading term 2n2 dan 200n2 – walaupun waktu sesungguhnya

Analysis of Algorithm

Required Reading

• Baca:

– Textbook A Chapter 10, 11.1

– Textbook B Chapter 8.1, 8.2, 8.4

Algoritma dan Analisa Algoritma

• Algoritma:

– prosedur/langkah2 penyelesaian problem

• Analisa algoritma:

– evaluasi sumber daya waktu dan tempat (time and – evaluasi sumber daya waktu dan tempat (time and space) yang digunakan suatu algoritma

– merepresentasikan hasil evaluasi dgn formula

– analisa kuliah ini fokus lebih pada waktu

– sumber daya/kebutuhan waktu algoritma juga disebut kompleksitas waktu (time complexity)algoritma

Mengukur Running Time

#include <ctime>

#include <iostream>

using namespace std;

int main() {

clock_t startTime, endTime;

startTime = clock();

long total;long total;

for (int i = 0; i < 10000000; i++) {

total += 1;

}

endTime = clock();

cout << "elapsed time = "

<< (endTime-startTime) / double(CLOCKS_PER_SEC)

<< endl;

}

Running Time Sesungguhnya

• Kita bisa mengukur waktu sesungguhnya program berjalan

– menggunakan jam atau code dalam program

• Unt hitung waktu sesungguhnya, analisa bergantung:

– bahasa pemrograman yg digunakan unt code algoritma

– data set/input ke algoritma

– hardware computer dimana algoritma dieksekusi

• Akan sulit membandingkan dua algoritma

• Ingin mengetahui perilaku algoritma sebelum ia

dieksekusi/dicode

– algoritma yang didesain dgn buruk dapat sangat lama

eksekusinya

Analisa Algoritma

• Bagaimana kita menganalisa algoritma?

– jangan hitung waktu sesungguhnya

– hitung banyaknya operasi yang diperlukan

– biasanya operasi yang dominan

• Contoh:• Contoh:for (int i=1; i<=n; i++) {

perform 100 operasi; // A

for (int j=1; j<=n; j++)

perform 2 operasi; // B

}

– total operasi = A + B = ?

Kebutuhan Waktu

• Bila mengetahui banyaknya operasi yang diperlukan

algoritma A:

– algoritma A memerlukan 2n2 + 100n operasi untuk

memecahkan problem berukuran n

• Jika waktu t yang diperlukan satu operasi diketahui,

– algoritma A memakan waktu (2n2 + 100n)*t unit waktu

– namun, nilai t tergantung dari faktor sebelumnya

• Dgn tidak menggunakan t, dapat dinyatakan

– algoritma A memerlukan waktu yang proposional dgn

2n2 + 100n unt memecahkan program berukuran n

Perkiraan Analisa Hasil

• Misal didapati kompleksitas:

– algoritma A adl 3n2 + 2n + log n + ¼ n

– algoritma B adl 0.3n3 + n

• Algoritma A akan lebih cepat dari algoritma B,

– dalam memecahkan problem besar (n besar)dalam memecahkan problem besar ( besar)

• Term yg mendominasi 3n2 dan 0.3n3 dapat

mengindikasikan bagaimana algoritma berjalan

– algoritma B dgn term lebih tinggi lebih buruk

• Bahkan, ingin term n2 dan n3 lebih sederhana

– diperoleh lewat asymptotic analysis

Asymptotic Analysis

• Analisa asymptotic adalah analisa algoritma

yang berfokus pada

– analisa problem dgn input size besar

– hanya memperhitungkan term terbesar dari– hanya memperhitungkan term terbesar dari

formula

– abaikan koefisien term terbesar (leading term)

Leading Term

• Mengapa memilih leading term?

– term2 dgn pangkat lebih kecil (lower order terms) berkontribusi lebih kecil thd cost total saat input bertambah banyak

– contoh:

– T(n) = 2n2 + 100n– T(n) = 2n2 + 100n

– T(1000) = 2(1000)2 + 100(1000)

– = 2000000 + 100000

– T(100000) = 2(100000)2 + 100(100000)

– = 20000000000 + 10000000

– dgn demikian, lower order term dapat diabaikan

Leading Term

• T1(n) = ½ n + 4

– leading term =

• T2(n) = 240n + 0.001n2

?

• T2(n) = 240n + 0.001n

– leading term =

• T3(n) = n lg(n) + lg(n) + n lg(lg(n))

– leading term =

?

?

Koefisien Leading Term

• Misal dua algoritma memiliki kompleksitas waktu dari leading term 2n2 dan 200n2

– walaupun waktu sesungguhnya akan berbeda karena konstan pada koefisien, laju pertumbuhan (growth rate) kedua algoritma sama(growth rate) kedua algoritma sama

– bila dibandingkan dgn algoritma dgn leading term n3, perbedaan pada growth rate lebih mendominasi

• Dengan demikian, kita drop koefisien leading term saat menentukan kompleksitas algoritma

Batas Atas (Upper Bound), Notasi Big-O

• Bila algoritma A perlu waktu proporsional dgnf(n)

– dikatakan algoritma A adalah order f(n)

– ditulis algoritma A adl O(f(n))

– f(n) adalah fungsi laju pertumbuhan algoritma A– f(n) adalah fungsi laju pertumbuhan algoritma A

• Definisi formal:

– algoritma A adl O(f(n)) bila ada sebuah konstan k

dan integer positif n0 sehingga algoritma A membutuhkan waktu tidak lebih dari k * f(n) unit waktu untuk memecahkan problem berukuran n >= n0

Big-O

• Saat ukuran problem lebih dari n0, algoritma A

dibatasi dari atas (bounded from above) oleh k*

f(n)

– n0 dan k tidak unik

– ada sejumlah f(n) yang mungkin

Contoh: Mencari n0 dan Konstan k

• Diberikan running time/kompleksitas algoritma A T(n) = 2n2 + 100n

• Buktikan bahwa T(n) = O(n2) !

• Solusi:• Solusi:– 2n2 + 100n < 2n2 + n2

– = 3n2 saat n > 100

– dgn k = 3 dan n0 = 100, sesuai definisi algoritma A adalah O(n2)

• Benarkah bila algoritma A: O(2n2)? O(3n2)? O(n3)?

Fungsi Laju Pertumbuhan

• Dgn definisi Big-O, jelas bahwa koefisien f(n)

dapat diserap oleh konstan k

– misal, algoritma A adl O(3n2) dgn konstan k1

– algoritma A adl O(n2) dgn konstan k = k1 * 3

– jadi, cukup ditulis dgn koefisien 1– jadi, f(n) cukup ditulis dgn koefisien 1

• Didapatkan growth term (order of growth, order

of magnitude), yang paling umum digunakan:

O(1)<O(lg n)<O(n)<O(n lg n)<O(n2) <O(n3)<O(2n)

baik buruk

Terminologi Growth Rate

• O(1) : constant time

– tidak dipengaruhi n

• O(lg n) : logarithmic time

– bertumbuh lambat, dobel input size, waktu bertambah konstan

• O(n) : linear time

– bertumbuh seiring laju n, dobel input size, dobel waktu

• O(n log n) : linearithmic time• O(n log n) : linearithmic time

– bertumbuh sedikit lebih cepat dari laju n

• O(n2) : quadratic time

– bertumbuh cepat, dobel input size, empat kali lipat waktu

• O(n3) : cubic time

– bertumbuh sangat cepat, dobel input size, delapan kali waktu

• O(2n) : exponential time

– bertumbuh terlampau cepat, tidak mungkin input size besar

Polynomial / Exponential Time

• O(nk) dgn k konstan disebut polynomial time

• Misal kita punya problem dgn n item yg dapatdipecahkan dgn algoritma yg mengecek 2n

kasuskasus

• Kita gunakan supercomputer yang dapatmenganalisa 200 juta kasus perdetik

– input 15 item, waktu = 163 mikrodetik

– input 30 item, waktu = 5.36 detik

– input 50 item, waktu = ?



• Misal kita punya problem dgn n item yg dapat

dipecahkan dgn algoritma yg mengecek 2n kasus

• Kita gunakan supercomputer yang dapat • Kita gunakan supercomputer yang dapat

menganalisa 200 juta kasus perdetik



– input 50 item, waktu = lebih dari 2 bulan

– input 80 item, waktu = ?



• Misal kita punya problem dgn n item yg dapat

dipecahkan dgn algoritma yg mengecek 2n kasus

• Kita gunakan supercomputer yang dapat • Kita gunakan supercomputer yang dapat

menganalisa 200 juta kasus perdetik



– input 50 item, waktu = lebih dari 2 bulan

– input 80 item, waktu = 191 juta tahun

Polynomial : Quadratic Time

• Sekarang, problem serupa namun algoritma 300n2

dgn komputer tablet 33MHz– input 15 item, waktu = 2 milidetik

– input 30 item, waktu = 8 milidetik

– input 50 item, waktu = 22 milidetik– input 50 item, waktu = 22 milidetik

– input 80 item, waktu = 58 milidetik

• Jadi, untuk mempercepat program, jangansemata2 andalkan kemampuan hardware komputer– sangatlah penting unt menggunakan algoritma efisien

untuk memecahkan masalah (problem solving)

Grafik Growth Rate (1)

Grafik Growth Rate (2)

Contoh Analisa Algoritma

1. Tower of Hanoi

2. Sequential Search

3. Binary Search

Tower of Hanoi

• Bagaimana memindahkan keping dari tiang A ke tiang B,

dengan hanya menggunakan tiang C?

– hanya 1 keping setiap kali

– keping harus berada di atas keping yang lebih besar

state awal

state akhir

Solusi Rekursif Tower of Hanoi

N-1

N-1N

Recursive Case

size = N-11

Problem asli

size = N

size = N-1

Base Case

size = 1

Recursive Case

size = N-1

void tower(int N, char source, char destination, char temporary)

{

if(N == 1)

pindah(source, destination);

else {

tower(N-1, source, temporary, destination);


Solusi Rekursif Tower of Hanoi


tower(N-1, temporary, destination, source);

}

}

void pindah(char x, char y)

{

cout << "dari " << x << " ke " << y << endl;

}

Banyaknya Pindah

Banyaknya keping

n

Banyaknya pindah

f(n)

Waktu

1 detik setiap pindah

1 1 1 detik

2 3 3 detik

3 7 7 detik

4 15 15 detik

5 31 31 detik

6 63 1 menit

. . . . . . . . .

16 65.536 18 jam

32 4,295 milyar 136 tahun

64 1,8 x 1010 milyar 584 milyar tahun

f(n) = 2n - 1

Tower of Hanoi

• Algoritma rekursif minggu lalu menggunakan

langkah sebanyak 2n-1

– asumsikan setiap langkah perlu waktu k

• Running time Tower of Hanoi = k (2n-1) =• Running time Tower of Hanoi = k (2n-1) =

O(2n)

• Algoritma Tower of Hanoi adalah algoritma

exponential time!

Sequential Search

int seqSearch(int a[], int len, int x)

{

for (int i = 0; i < len; i++) {

if (a[i] == x)

return i;

}}

throw string("Tidak ketemu");

}

• Berapa running time / kompleksitas waktu

algoritma sequential search? ?

Analisa Algoritma : Kasus Input

• Selain tergantung pada banyaknya input n, running time algoritma juga tergantung dari jenis input (kasus/case)

• Ada tiga kasus analisa algoritma:– Worst Case Analysis: skenario jenis input terburuk

– Best Case Analysis: kasus ideal, kurang berguna– Best Case Analysis: kasus ideal, kurang berguna

– Average Case Analysis: sulit, tahu distribusi input

• Pd sequential search:– worst case:

– best case:

– average case: ?

Sequential Search• Analisa algoritma:

– waktu yang diperlukan setiap iterasi dalam loop paling besar suatu konstan k1

– waktu yang diperlukan di luar loop paling besarsuatu konstan k2

– banyak iterasi maksimum n– banyak iterasi maksimum n

– running time = k1n + k2 = O(n)

• Contoh analisa worst case

– jaminan semua kasus / jenis input

• Secara umum, n iterasi satu loop adalah linear O(n)

Binary Search

• Karakteristik penting:

– input array sudah sorted / diurutkan

– pencarian pada subarray dimana item yang dicarix mungkin berada

– berulang kali membandingkan x dgn elemen– berulang kali membandingkan x dgn elementengah subarray m

• jika x == m, ketemu!

• jika x > m, carilah di posisi setelah m

• jika x < m, carilah di posisi sebelum m

• Implementasi rekursif dibahas minggu lalu!

Binary Search Rekursif

int binarySearch(int a[], int x, int low, int high)

{

if (low > high)

return -1;

int mid = (low + high) / 2;

if (x < a[mid])

base case 1 : item tidak ketemu

recursive case : cari

di subarray kiri atau kananif (x < a[mid])

return binarySearch(a, x, low, mid – 1);

if (x > a[mid])

return binarySearch(a, x, mid + 1, high);

return mid;

}base case 2 : item ketemu

int binarySearch(int a[], int n, int x)

{

int mid, low = 0, high = n - 1;

while (low <= high) {

mid = (low + high) / 2;

if (x == a[mid])

Binary Search Iteratif

if (x == a[mid])

return mid;

else if (x > a[mid])

low = mid + 1;

else

high = mid - 1;

}

return -1;

}

Analisa Iterative Binary Searching (1)

• Waktu yg diperlukan diluar loop plg bnyk k1

• Waktu yg diperlukan pada setiap iterasi loop plg bnyk k2

• Untuk input berukuran n, jika program • Untuk input berukuran n, jika program melakukan plg bnyk f(n) iterasi, maka:

T(n) = k1 + k2 f(n)

= O(f(n))

• Dengan demikian, waktu ditentukan olehbanyaknya iterasi (looping)


• Sewaktu binary search berlangsung, subarray

yang mengandung x yang dicari

– setiap iterasi loop mengurangi setengah subarray tsb

• Awalnya, seluruh array n elemen dicari• Awalnya, seluruh array n elemen dicari

– iterasi 1, plg bnyk n/2 tersisa

– iterasi 2, plg bnyk (n/2)/2 = n/4 = n/22 tersisa


– . . .

– iterasi i, plg bnyk tersisa

– iterasi terakhir, plg bnyk 1 elemen tersisa


• Sewaktu binary search berlangsung, subarrayyang mengandung x yang dicari

– setiap iterasi loop mengurangi setengah subarray tsb

• Awalnya, seluruh array n elemen dicari

– iterasi 1, plg bnyk n/2 tersisa– iterasi 1, plg bnyk n/2 tersisa



– . . .

– iterasi i, plg bnyk n/2i tersisa

– iterasi terakhir, plg bnyk 1 elemen tersisa


• Pd worst case, kita harus mencari hingga

iterasi terakhir k saat hanya 1 elemen tersisa

– n/2k = 1

– 2k = n

?– 2 = n

– k =

• Dgn dmkn, algoritma binary search memiliki

kompleksitas waktu O( )

?

?

Quiz 1 – Range

• Diberikan sebuah vector (atau array) integer,

tulis fungsi range untuk mencari range vector

tersebut!

– range adalah selisih terbesar dari sepasang– range adalah selisih terbesar dari sepasang

elemen dalam vector

– contoh: range({ 24, 5, 18, 9, 32, 7 }) = 27

• Berikan algoritma yang paling efisien!

– analisa algoritma tersebut !

int range1(vector<int>& v) {

int maxSlsh = 0;

for (int i = 0; i < v.size(); i++) {

for (int j = 0; j < v.size(); j++) {

int slsh = abs(v[j] - v[i]);

maxSlsh = max(maxSlsh, slsh);

Quiz 1 Algoritma Range 1


}

}

return maxSlsh;

}

• Berapakah running time fungsi/algoritma di atas?


int maxSlsh = 0;

for (int i = 0; i < v.size(); i++) {

for (int j = 0; j < v.size(); j++) {



}


}

}

return maxSlsh;

}


T(n)=2n2

O(n2)


int maxSlsh = 0;

for (int i = 0; i < v.size(); i++) {

for (int j = i + 1; j < v.size(); j++) {





}

}

return maxSlsh;

}



int maxSlsh = 0;

for (int i = 0; i < v.size(); i++) {

for (int j = i + 1; j < v.size(); j++) {





}

}

return maxSlsh;

}


T(n)=n(n-1)/2

O(n)=n2


int hi = v[0];

int lo = v[0];

for (int i = 1; i < v.size(); i++) {

hi = max(hi, v[i]);

lo = min(lo, v[i]);


lo = min(lo, v[i]);

}

return hi - lo;

}



int hi = v[0];

int lo = v[0];

for (int i = 1; i < v.size(); i++) {

hi = max(hi, v[i]);

lo = min(lo, v[i]);


lo = min(lo, v[i]);

}

return hi - lo;

}


T(n)=n-1

O(n)=n

Quiz 2 – MaxSum

• Diberikan sebuah vector (atau array) integer, tulis fungsi maxSum untuk mencari jumlah elemenberurutan terbesar pada vector tersebut!

– jika semua positif, tentu saja seluruh vector

– jika ada negatif? (jika semua negatif, maxSum = 0)– jika ada negatif? (jika semua negatif, maxSum = 0)

– contoh:

– maxSum({ 3, 5, -10, 15, 8, -7, 24, -6, 2 }) = 40

• Berikan algoritma yang paling efisien!

– analisa algoritma tersebut !

int maxSum1(vector<int>& v) {

int max = 0;

for (int i = 0; i < v.size(); i++) {

for (int j = i; j < v.size(); j++) {

int sum = 0;

for (int k = i; k <= j; k++)

sum += v[k];

if (sum > max)

Quiz 2 Algoritma MaxSum 1

if (sum > max)

max = sum;

}

}

return max;

}


Kelemahan Algoritma MaxSum1

• Terjadi perhitungan berulang saat menghitung

sum!

• Misal:

– menghitung sum antar index 2 dan 5:– menghitung sum antar index 2 dan 5:

– v[2] + v[3] + v[4] + v[5]

– saat menghitung sum antar index 2 dan 6 selanjutnya:

– v[2] + v[3] + v[4] + v[5] + v[6]

– saat menghitung sum antar index 2 dan 7 selanjutnya:

– v[2] + v[3] + v[4] + v[5] + v[6] + v[7]


int max = 0;

for (int i = 0; i < v.size(); i++) {

int sum = 0;

for (int j = i; j < v.size(); j++) {

sum += v[j];

if (sum > max)


if (sum > max)

max = sum;

}

}

return max;

}


Perbaikan Algoritma• Perbaikan 1: deretan max sum tidak mungkin dimulai

dari deretan berjumlah negatif

• Perbaikan 2: jumlah elemen dari i s/d j-1 positif, namun

jumlah elemen dari i s/d j negatif, deretan max sum yg

berakhir setelah j tidak mungkin dimulai dari i s/d j


int max = 0, sum = 0, i = 0;

for (int j = 0; j < v.size(); j++) {

if (sum < 0) {

i = j;

sum = 0;

}

sum += v[j];


sum += v[j];

if (sum > max)

max = sum;

}

return max;

}


Selanjutnya : Sorting 1

• Selection Sort

• Bubble Sort

• Insertion Sort

Referensi

• Purwanto, E., 2014, Slide kuliah Struktur Data,

Yogyakarta : UKDW

• Kadir, A.,2003, Pemrograman C++, Yogyakarta

: Andi: Andi

Analysis of Algorithm · 2019-05-17 · Koefisien Leading Term • Misal dua algoritma memiliki kompleksitas waktu dari leading term 2n2 dan 200n2 – walaupun waktu sesungguhnya

Documents