Brahmantio Farhan Rabbani

21/482806/TK/53375

Analisis Algoritma

Tugas :

Buatlah analisis algoritma terhadap implementasi kode program dalam suatu Bahasa
Pemrograman C++, dengan ketentuan sebagai berikut.

1. Pilih contoh algoritma kategori konstan O(1)

- Jalankan untuk data input yang bervariasi,
Misal dengan ukuran 10, 100, 1000, 10.000, 100.000, 1000.000.
Masing-masing 5 kali eksekusi untuk mendapatkan gambaran yang lebih baik.
- Catat waktu eksekusi (bisa di-screenshot), misal dalam milisecond
- Tuliskan analisismu berdasarkan hasil yang diperoleh. Misalnya apakah waktu eksekusi benar-
benar konstan.

2. Ulangi eksperimen untuk suatu algoritma kategori linear O(n)

3. Ulangi eksperimen untuk suatu algoritma kategori quadratic O(n^2)

1. Constant O(1)
Dalam percobaan untuk mendapatkan Constant Time Growth Rate Function. Kita, dapat
menggunakan code yang simple (berisi hanya statement saja). Code ini hanya menamplikan
angka sesuai dengan input yang ditentukan dan juga execution time nya. Dalam code
digunakan library chrono untuk dapat menampilkan execution time. Berikut adalah code yang
digunakan,

Dengan menggunakan code seperti itu, kita hanya menggunakan beberapa statement saja dan
kita mengetahui bahwa setiap statement memiliki nilai time sebesar 1 (sebuah konstanta). Oleh
karena itu, Growth rate dari fungsi tersebut adalah O(1) atau constant time. Lalu, kita mencoba
mengeksekusi beberapa inputan berbeda, yaitu 10, 100, 1000, 10000, 100000, 1000000.

1.) 10 (input)

Hasil eksekusi program dengan menginput nilai n = 10 tidak memakan waktu yang banyak
dan tiap execution time-nya memiliki perbedaan yang tidak terlalu jauh. Rata- rata dari
execution time-nya adalah 1038,2 microseconds atau setara dengan 1,0382 detik.
2.) 100 (input)

Hasil eksekusi program dengan menginput nilai n = 100 tidak memakan waktu yang banyak
dan tiap execution time-nya memiliki perbedaan yang tidak terlalu jauh (sama seperti input
sebelumnya). Rata – rata dari execution time-nya adalah 1060,8 microseconds atau setara
dengan 1,0608 detik. Hal ini menunjukkan bahwa penginputan nilai dengan n yang berbeda
menghasilkan execution time yang tidak memiliki perbedaan signifikan.

3.) 1000

Hasil Eksekusi dari penginputan nilai n = 100 juga tidak memakan waktu yang banyak dan
bisa dilihat perbedaan dari tiap execution time tidak jauh. Rata- rata dari execution time-nya
adalah 1022,4 microseconds atau setara dengan 1,0224 detik. Hal ini juga meyakinkan kita
bahwa growth rate dari fungsi tersebut adalah O(1) atau constant time.
4.) 10000

Hasil eksekusi dari penginputan number = 10000 juga masih menghasilkan rata-rata
execution time yang tidak berbeda jauh, yaitu 1063,2 microseconds atau setara dengan 1,0632
detik. Dengan hasil execution time tersebut kita menyadari bahwa input n = 1000 (lebih besar
dari 10,100, dan 1000) tidak mempengaruhi waktu eksekusinya.

5.) 100000

Hasil eksekusi dari penginputan nilai n = 100000 memiliki nilai rata-rata execution time
yang tidak jauh dari sebelumnya ( n = 10, 100, 1000, dan, 10000), yaitu 1046,8 microsecond
atau setara dengan 1,0468 detik.
6.) 1000000

Hasil eksekusi dari penginputan n = 1000000 juga tidak mempengaruhi execution time yang
didapat. Rata – rata dari execution time-nya adalah 1005,8 microseconds atau setara dengan
1,0058 detik.

• Hasil Analisis
Input Rata – rata execution time
10 1,0382 seconds
100 1,0608 seconds
1000 1,0224 seconds
10000 1,0632 seconds
100000 1,0468 seconds
1000000 1,0058 seconds

Dari percobaan yang dilakukan, kita memperoleh rata – rata execution time dari tiap
inputan berbeda yang hasilnya tidak jauh beda (konstan). Hal ini, meyakinkan kita
bahwa algoritma yang memiliki growth rate function, yaitu constant time atau O(1)
memiliki excecution time yang konstan. Dengan kata lain, berapapun input atau size-n
nya tidak akan mempengaruhi execution time dari tiap n.
2. Linear O(n)
Linear Growth Rate Functions memiliki execution time yang meningkat sesuai dengan
input (n) atau size-n yang diberikan. Dalam menganalisis apakah pernyataan tersebut benar,
digunakan fungsi for loop yang memakan waktu (n+1). Maka dari itu, digunakan for loop untuk
memberikan nilai mendekati linear pada growth rate-nya atau O(n). Berikut adalah code yang
digunakan untuk percobaan.

Dalam percobaan ini, kita masih menggunakan input yang sama, yaitu 10, 100, 1000,
10000, 100000, 1000000.

1.) 10

Hasil eksekusi yang dihasilkan dari input n = 10 tidak memakan waktu yang banyak
dan execution time dari tiap eksekusi tidak memiliki perbedaan yang jauh. Rata – rata dari
execution time-nya adalah 1002,6 microseconds atau setara dengan 1,0026 detik.
2.) 100

Hasil eksekusi yang dihasilkan dari input n = 100 memakan waktu yang
singkat, dapat dilihat juga hasil tiap waktu eksekusi tidak memiliki perbedaan yang
jauh. Rata – rata dari execution time-nya adalah 1009,8 microseconds atau setara
dengan 1,0098 detik.

3.) 1000

Hasil waktu eksekusi yang diberikan untuk input n = 1000 memiliki kenaikan
rata – rata dari n sebelumnya, yakni rata – rata execution time-nya adalah 1033,8
microseconds atau setara dengan 1,0338 seconds. Dengan pola tersebut, dapat diambil
hipotesis bahwa untuk n yang lebih besar membutuhkan waktu eksekusi yang lebih
lama pula.
4.) 10000

Hasil waktu ekseskusi dari input n = 10000 menunjukkan bahwa hipotesis yang
disebutkan tadi benar. Karena rata – rata dari execution time-nya adalah 1215,4
microseconds atau lebih tepatnya 1,2155 detik ( lebih lama dari n = 10, 100, dan 1000).
5.) 100000

Hasil waktu eksekusi dari input n = 100000 juga memiliki peningkatan dalam
execution time-nya, dengan rata – rata waktu eksekusinya sebesar 1481,1
microseconds atau setara dengan 1,4811 detik.
 6.) 1000000

Hasil waktu eksekusi dari penginputan n = 1000000 menghasilkan peningkatan yang

cukup signifikan dari inputan sebelumnya ( n = 100000), rata – rata dari execution time-
nya adalah 3491,4 microseconds atau setara dengan 3,4914 detik. Hasil ini menunjukkan
bahwa semakin besar nilai n, waktu yang dibutuhkan untuk mengeksekusinya juga semakin
lama.

• Hasil Analisis
Inputan Rata – rata execution time
10 1,0026 seconds
100 1,0098 seconds
1000 1,0338 seconds
10000 1,2155 seconds
100000 1,4811 seconds
1000000 3,4914 seconds
Dari percobaan yang telah dilakukan dengan penginputan yang berbeda beda
(n = 10, 100, 1000, 10000,100000, 1000000), dapat disimpulkan bahwa algoritma
tersebut dipastikan memiliki growth rate yang linear atau O(n) karena semakin besar
size-n, waktu eksekusinya semakin tinggi walaupun peningkatannya tidak terlalu jauh
( perlahan).

3. Quadratic O(𝒏𝟐 )
Quadratic Growth Rate Function atau O(𝑛2 ) memiliki waktu eksekusi yang akan
meningkat cepat berdasarkan input yang diberikan, peningkatan tersebut akan terlihat lebih
signifikan dibandingkan dengan algoritma linear. Dalam melakukan percobaan kali ini, kita
akan menggunakan nested for loop dengan tujuan untuk mendapat execution time n*(n+1)
nantinya algoritma ini akan memiliki Growth Rate yang mendekati Quadratic atau O(𝑛2 ).
Berikut adalah code yang digunakan.

Dengan menggunakan nested for loop dalam algoritma, kita dipastikan akan mendapat
waktu eksekusi yang mendekati Quadratic Growth Rate Function atau O(𝑛2 ). Dalam
percobaan kali ini, digunakan inputan n = 10, 100, 1000, 10000, dan 50000. Dalam algoritma
ini (quadratic), pengeksekusian untuk n > 100000 memiliki waktu eksekusi yang cukup lama.
Pada akhirnya, digunakan 500000 sebagai inputan n terbesar.

1.) 10
 Hasil eksekusi dari penginputan n = 10 menghasilkan execution time yang tidak jauh
dengan algoritma sebelumnya (constant dan linear). Rata – rata dari execution time-nya
adalah 1113,2 microseconds atau setara dengan 1,1132 detik.
2.) 100

Hasil waktu eksekusi dari penginputan n = 100 tidak memakan waktu yang singkat dan
execution time yang dihasilkan memiliki peningkatan dibandingkan n = 10. Rata – rata
execution time-nya adalah 1139,2 microseconds atau setara dengan 1,1392 detik.
3.) 1000

Hasil eksekusi dari penginputan n = 1000 menghasilkan execution time yang

mengalami peningkatan dari input sebelumnya. Rata – rata execution time-nya adalah
2118,2 microseconds atau setara dengan 2,1182 detik. Hasil ini menunjukkan, perbedaan
yang signifikan karena sebelumnya hasil waktu eksekusinya masih berada di rentang 1
detik.
4.) 10000

Hasil eksekusi dari algoritma tersebut dengan penginputan n = 10000 menghasilkan

execution time yang mengalami peningkatan cukup signifikan daripada input sebelumnya.
Rata – rata execution time-nya adalah 123036,2 microseconds atau setara dengan 123,0362
detik. Hasil ini sangat jauh meningkat dari input sebelumnya ( n = 1000).

5.) 50000

Hasil eksekusi dalam percobaan terakhir ini, digunakan input n = 50000 sebagai
sample input tertinggi. Waktu eksekusi yang dihasilkan juga memiliki peningkatan yang
sangat tinggi dari input sebelumnya (n = 10000) . Rata – rata dari execution time-nya adalah
2.919.758,8 microseconds atau setara dengan 2.919,7588 detik. Dari lima pecobaan
tersebut, kita dapat menyimpulkan hal tentang waktu eksekusi dari algoritma quadratic.
 • Hasil Analisis
Input Rata – rata execution time
10 1,1132 seconds
100 1,1392 seconds
1000 2,1182 seconds
10000 123,0362 seconds
50000 2.919,7588 seconds
Setelah melakukan percobaan tersebut, kita dapat menyimpulkan bahwa
algoritma tersebut memiliki Quadratic Growth Rate Function atau O(𝑛2 ) dan
algoritma tersebut memiliki peningkatan yang sangat cepat sesuai dengan input atau
size-n yang diberikan. Lalu, kita dapat menyimpulkan bahwa quadratic algorithm
memiliki waktu eksekusi yang meningkat begitu cepat dibandingkan dengan algortma
sebelumnya (constant dan linear).

4. Kesimpulan
Setelah melakukan percobaan, dalam menganalisis algoritma kita tidak hanya
membandingkan source code-nya saja. Akan tetapi, kita bisa membandingkan waktu
eksekusi dari tiap algoritma untuk mendapatkan solusi yang efisien dan dari percobaan
yang dilakukan , lama waktu eksekusi yang dihasilkan sesuai dengan algoritma –
algoritma tertentu. Berikut adalah grafik yang menunjukkan perbedaaan dalam tiap
Growth- rate dari tiap algoritma.

Berdasarkan percobaan yang telah dilakukan, kita telah membuktikan bahwa

Constant Growth-rate function memiliki waktu eksekusi yang cukup stabil. Lalu,
algoritma yang memiliki for loop didalamnya (Linear Growth – rate function ),
menghasilkan waktu eksekusi yang bertambah sesuai dengan size-n (input). Setelah
itu, algoritma yang memiliki nested for loop didalamnya (Quadratic Growth – rate
function), menghasilkan waktu eksekusi yang meningkat sangat cepat dari setiap
kenaikan nilai size-n (input). Maka dari itu, pecobaan ini mendukung kebenaran dari
grafik di atas.