Dokumen ini membahas tentang efisiensi algoritma, menyoroti pentingnya algoritma yang tidak hanya memberikan hasil yang benar, tetapi juga melakukannya dalam waktu dan memori yang efisien. Faktor-faktor yang mempengaruhi efisiensi mencakup banyak langkah, jenis dan ukuran input data, serta alokasi memori. Kesimpulannya, algoritma yang efisien dapat membantu mengurangi waktu eksekusi dan penggunaan memori, sehingga meningkatkan kinerja aplikasi.

1. Algoritma ©
“Efisiensi dari Algoritma”
Kelompok 5
No.Absen Nama Kelompok NIM
18 Veronica Ambassador 1404505011
19 Muhammad Rifky Lukman 1404505012
20 I Made Budi Setiawan 1404505013
21 I Gusti Putu Sena Sila Adnyana 1404505014

2. Latar Belakang
Setiap bidang memiliki permasalahannya sendiri dan membutuhkan
algoritma yang efisien. Masalah yang berkaitan di satu bidang terkadang dipelajari
bersama. Beberapa contoh yaitu algoritma pencarian, algoritma
penggabungan, algoritma numerik, algoritma grafik, algoritma deret, algoritma
komputasi geometri, algoritma kombinatorial algoritma medis, mesin
belajar, kriptografi, algoritma kompresi data dan teknik penguraian.
Terkadang bidang-bidang tersebut saling tumpang tindih, dan
perkembangan algoritma di satu bidang bisa meningkatkan bidang lainnya yang
terkadang malah tidak saling berkaitan.
Algoritma menyelesaikan masalah tanpa memberatkan bagian lain dari
aplikasi. Sebuah algoritma yang tidak efisien akan menggunakan sumber daya
(memori, CPU) yang besar dan memberatkan aplikasi yang mengimplementasikan
algoritma tersebut.

3. Efisiensi Algoritma
Algoritma yang dapat dikatakan sebagai algoritma yang efisien,
merupakan algoritma yang dimana pada saat pemrosesan algoritma tersebut tidak
memakan banyak waktu dan juga ditak memakan banyak memori dalam
pemrosesannya.
Walaupun algoritma memberikan keluaran yang benar (paling mendekati
kenyataan), tetapi jika harus menunggu berjam-jam atau mungkin berhari-hari untuk
mendapatkan outputannya (dalam hal ini yang dimaksudkan adalah efisiensi dalam
waktu), algoritma tersebut biasanya tidak akan dipakai. Kebanyakan orang lebih
menginignkan algoritma yang memiliki pengeluaran atau hasil outputan yang lebih
cepat.

4. Faktor Yang Mempengaruhi
Efisiensi Algoritma
Kecepatan :
a. Banyak langkah
b. Besar dan jenis input data
c. Operator
Space
a. Alokasi memory

5. Banyak Langkah
•Sequensial
1 operasi
sin (x) → 1 operasi
sin (x*pi/1000) → 3 operasi
•Branching / Percabangan
k = kondisi dengan banyak langkah c
s1,s2 = blok statement dengan banyak langkah p1,p2
If (kondisi/k) Then statement s1
Else statement s2
Jika n(kondisi) = waktu tempuh kondisi → 2 operasi
n(s1) = waktu tempuh statement s1 → 5 operasi
n(s2) = waktu tempuh statement s2 → 3 operasi
Maka
waktu tempuh = n(kondisi) + max(n(s1),n(s2))
= 2 + 5 = 7
Diambil yang terbesar,
yaitu s1=2 langkah

6. Banyak Langkah
•Looping
Rumus banyak langkah :
(akir – awal + 2) + (akhir – awal + 1) (p + 1)
p = banyak langkah statement
for i = 1 to n
x : =x+5
y : =y+x
Penyelesaian :
Langkah = (akhir – awal + 2) + (akhir – awal + 1) (p+1)
= (n -1 + 2) + (n – 1 + 1) (2 + 1)
= (n + 1) + (n)(3)
= n + 1 + 3n
= 4n + 1
•Subroutine call (bisa memanggil prosedur dan bisa memanggil fungsi)
Pada bagian ini analisa lebih cenderung di pandang bagaimana suatu operasi di lakukan
pada level bawah (low level), yaitu pada level pemrosesan melakukan operasi secara mikro di
prosesor dan hal ini juga tergantung pada compiler yang di pergunakan, apakah optimasi dapat
dilakukan/diberikan atau tidak.

7. Besar dan jenis input data:
•Input Size
Menggunakan notasi n (jumlah data yang diperoleh oleh sebuah algoritma).
Contoh :
Algoritma pengurutan 1000 elemen larik, maka n = 1000
•Tipe data
Dua nilai yang sama dengan operator yang sama tetapi dengan variabel
yang berbeda, maka terdapat perbedaan kecepatan / proses penyelesaiannya.
Integer
250 + 17 = 267 → 1 langkah
Real
250.0 + 17.0 = 0.25 * 103 + 0.17 * 102 → 3
= 0.25 * 103 + 0.017 * 103 → 3
= (0.25 + 0.017 ) * 103 → 32
= 0.267 * 103 → 1 +
= 267.0 → 9 langkah

8. Operator
Urutan penggunaan operator/penempatan operator bisa mempengaruhi efisiensi. Contoh
perkalian (*) lebih lama daripada penjumlahan (+).Yang perlu diperhatikan adalah banyaknya
operasi aritmatika dan logika yang dilakukan.
Operator dasar logika : AND, OR, NOT di hitung 1 langkah
Operator aritmatik : ^,+,-,*,/ dihitung 1 langkah
Operator aritmatik : % di hitung 2 langkah
Not (P AND Q) mempunyai langkah sebanyak 2
2<5 → bukan operator tapi konstanta logika karena tidak menghasilkan nilai yang sejenis
Contoh :
x = 2<5 → Tidak ada operasi
x = True → Tidak ada operasi
y = 5 → Tidak ada operasi
y = 5 + 0 → 1 operasi
y = 3 * 5 + 2→ 2 operasi

9. Alokasi memory
Algoritma yang memakan banyak memori merupakan algoritma yang dapat
dikatakan memiliki kualitas buruk. Semakin besar memori yang terpakai untuk algoritma
tersebut, maka akan semakin buruk algoritma tersebut.
Misal :
satuan variable dsn konstanta yang bertipe : int, real/float beasrnya dianggap sama
(missal 4 byte atau 8 byte). Char dianggap 1 byte
→float array [2][2] = 4*4 byte = 16 byte

10. Kompleksitas Algoritma
Efisiensi suatu algoritma dapat diukur dari waktu eksekusi algoritma dan kebutuhan
ruang memori. algoritma yang efisien adalah algoritma yang meminimumkan kebutuhan waktu
dan ruang. dengan menganalisis beberapa algoritma untuk suatu masalah, dapat
diidentifikasikan satu algoritma yang paling efisien. Besaran yang digunakan untuk menjelaskan
model pengukuran waktu dan ruang ini adalah kompleksitas algoritma.
Kompleksitas dari suatu algoritma merupakan ukuran seberapa banyak komputasi
yang dibutuhkan algoritma tersebut untuk menyelesaikan masalah. secara informal, algoritma
yang dapat menyelesaikan suatu permasalahan dalam waktu yang singkat memiliki
kompleksitas yang rendah, sementara algoritma yang membutuhkan waktu lama untuk
menyelesaikan masalahnya mempunyai kompleksitas yang tinggi.

11. Terdapat banyak cara untuk mengukur efisiensi sebuah algoritma. Mari kita lihat
cara mengukur efisiensi yang paling sederhana terlebih dahulu: melihat berapa langkah yang
perlu dijalankan untuk menyelesaikan algoritma tersebut. Jika kita memanggil fungsi pangkat
seperti berikut:
pangkat(2, 1)
Maka kode akan dieksekusi seperti berikut:
hasil = 1
for i in range(0, 1):
hasil = 2 * hasil
return hasil
Perulangan for yang ada kita kembangkan dan akan menjadi:
hasil = 1
hasil = 2 * hasil
return hasil
Total terdapat tiga langkah yang perlu dijalankan untuk mendapatkan hasil pangkat yang
diinginkan.

12. Bagaimana jika kita naikkan nilai dari y sehingga kita memanggil pangkat(2, 2) ?
Kode yang dieksekusi akan menjadi:
hasil = 1
for i in range(0, 2):
hasil = 2 * hasil
return hasil
yang ketika diuraikan menjadi:
hasil = 1
hasil = 2 * hasil
hasil = 2 * hasil
return hasil
dengan total 4 langkah eksekusi.

13. Berdasarkan apa yang kita dapatkan sejauh ini, kita dapat menyimpulkan bahwa jika dilakukan
pemanggilan pangkat(2, 5) maka kita akan mendapatkan hasil eksekusi:
hasil = 1
hasil = 2 * hasil
hasil = 2 * hasil
hasil = 2 * hasil
hasil = 2 * hasil
hasil = 2 * hasil
return hasil
Kesimpulan yang bisa kita tarik dari hal ini adalah, baris hasil = x * hasil
dijalankan sebanyak y kali

14. Tabel di bawah menampilkan berapa kali setiap baris yang ada dalam fungsi pangkat
dieksekusi:
Baris Kode | Jumlah Eksekusi
hasil = 1 | 1
hasil = x * hasil | y
return hasil | 1
Sehingga kita dapat mengatakan bahwa fungsi pangkat akan selalu diselesaikan
dalam 2 + y langkah.

15. Melihat bagiamana y akan mempengaruhi jumlah langkah eksekusi, mari kita lihat seberapa
banyak pengaruh y terhadap jumlah langkah eksekusi kode:
Y Proses Perhitungan Jumlah Langkah
1 2 + 1 3
10 2 + 10 12
100 2 + 100 102
1000 2 + 1000 1002
10000 2 + 10000 10002
Dari tabel di atas kita dapat melihat bagiamana semakin meningkatnya jumlah dari y, semakin
nilai 2 yang ditambahkan menjadi tidak relevan.

16. SIMPULAN
Jadi dalam suatu algoritma, haruslah algoritma yang
efisiensi akan waktu dan memori, karena jika tidak maka
pemrosesan dari algoritma tersebut akan menjadi lama,
berat, dan tidak efisien pastinya.