Nama : Fikri Hidayattullah

Nim : 1644190062
Jurusan : Teknik Informatika S1

Tugas : Desain & Analisa Algoritma

 Efisiensi Algoritma
Setiap bidang memiliki permasalahanya sendiri dan membutuhkan algoritma yang efisien.
Masalah yang berkaitan di satu bidang terkadang dipelajari Bersama. Beberapa contoh yaitu,
algoritma pencarian, algoritma penggaungan, algoritma numerik, algoritma grafik, algoritma
daret, algoritma komputasi geometri, algoritma kombinatorial alagoritma 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 suber daya (mempri, CPU) yang besar dan
memberatkan aplikasi yang mengimplementasikan algoritma tersebut.

 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
tidak 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 mendapatkkan
outputnya (dalam hal ini dimaksud adalah efisiensi dalam waktu), algoritma tersebut bisanya
tidak akan di pakai. Kebanyakan orang lebih menginginkan algoritma yang memiliki pengeluaran
atau hasil output yang lebih cepat.

 Faktor Yang Mempengaruhi Efisiensi Algoritma

A. Kecepatan
- Banyak Langkah
- Besar dan jenis input data
- Operator
 B. Space
- Alokasi Memori

 Banyak Langkah
1. Sequensial
1 oprasi
x=0
y=1
x+y

sin (x) 1 operasi

sin (x*pi/1000) 3 Operasi

 Branching / Percabangan
K = kondisi dengan banyak Langkah c
s1, s2 = blok statement dengan banyak langak p1, p2

if (kondisi /k) than statement s1

Diambil yang terbesar
yaitu s1 = 2 langkah
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
  Looping
Rumus banyak Langkah :
(akhir – awal + 2) + (akhir – awal + 1) (p + 1)

p = banyak langkah statement

for i = 1 ton n
x : =x+5
y : =y+x
Penyelesaian :

Langakah = (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 melakukan operasi
secara micro di prosesor dan hal ini juga tergantung pada compolier yang di pergunakan, apakah
optimasi dapat dilakukan/diberikan atau tidak.

Besar dan jenis input data

 Input size
Menggunakan notasi n (jumlah data yang di peroleh oleh sebuah algoritma)
Contoh :
Algoritma pengurutan 1000 elemen larik, maka n = 1000

 Tipe data
Dua nilai yang sama dengan operator yang sama tetapi dengan variable yang berbeda,
maka terdapat perbedaan kecepatan / proses penyelesaian nya.
 Interger
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

Operator
Urutan penggunaan operator / penempatan operator bisa mempengaruhi efisiensi.
Contoh perkalian (*) lebih lama dari penjumlahan (+). Yang perlu di perlu di perhatikan
adalah banyaknya operasi aritmatika yang logika yang di butuhkan.

Operator dasar logika : AND, OR, NOT di hitung 1 langkah

Operator aritmatik : ˄,+,-,*,/ di hitung 1 langkah
Operator aritmatik % di hitung 2 langkah

Not (PAND Q) mempunyai Langkah sebanyak 2

2<5  buka operator tetapi 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

Alokasi memory
Algoritma yang memakan banyak memori merupakan algoritma yang dapat di katakana
sebagai algoritma yang memiliki kualitas buruk. Semakin besar memori yang terpakai untuk
algoritma tersebut maka akan semakin buruk algoritma tersebut.

Missal :
 Satuan variable dan konstanta yang bertipe : int, real/float besarnya di anggap
sama (missal 4 byte atau 8 byte) Char di anggap 1 byte  Float array [2] [2] = 4*4 byte = 16
byte

Kompleksitas Algortima
Efisiensi algoritm dapat di ukur dari waktu eksekusi algoritma dan kebutuhan ruang
memori. Algoritma yang efisien adalah algoritma yang meminimum kan kebutuhan waktu
dan ruang. Dengan menganalisis beberapa algoritma untuk suatu masalah, dapat di
identifikasikan sebuah satu algoritma yang efisien. Besaran yang di gunakan untuk
menjelaskan model pengukuran waktu dan ruang ini adalah kompleksitas algoritma.

Besaran yang di gunakan untuk menjelaskan model pengukuran waktu dan ruang ini
adalah kompleksitas algoritma. Kompleksitas dari suatu algoritma merupakan ukuran
seberapa banyak komputasi yang di butuhkan algoritma tersebut untuk menyelesaikan
masalah, secara informal, algoritma yang dapat menyelesaikan suatu permasalah dalam
waktu yang singkat memiliki kopleksitas yang rendah, sementara algoritma yang
membutuhkan waktu lama untuk menyelsaikan masalahnya mempunyai kompleksitas yang
tinggi.

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 yang akan di eksekusi sebagai 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 di jalankan untuk mendapatkan hasil pankat yang di
inginkan.

Bagaimana jika kita naikan nilai dari y sehingga kita memanggil pangkat (2,2) ?
Kode yang di eksekusi 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

dengan total 4 langkah eksekusi

berdasarkan apa yang kita dapatkan sejauh ini, kita dapat menyimpulkan bahwa jika
dilakukan panggilan 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 dapat kita Tarik dari hal ini adalah, baris hasil = x * hasil
dijalankan sebanyak y kali

tabel di bawah menampilakann beberapa kali setiap baris yang ada dalam fungsi pangkat
dieksekusi :

Baris Kode | jumlah ekseskusi

Hasil = 1 |1
Hasil = x * hasil |y
Return hasil |1

Sehingga kita dapat mengatakan bahwa fungsi pangkat akan selalu diselesaikan dalam 2 + y
Langkah.
Kesimpulan

Jadi dalam satuan algoritma, haruslah algoritma yang efisieni akan waktu dan memori,
karena jika tidak maka pemrosesan dari algoritma tersebut akan menjadi lama, berat dan
tidak efisien pastinya