KOMPLEKSITAS

RUANG DAN
WAKTU
TINJAUAN
Sebuah algoritma tidak hanya harus benar tetapi juga
harus mangkus (efficient)
Sebuah algoritma yang benar bisa menjadi tidak
berguna untuk jenis dan ukuran masukan tertentu,
karena waktu yang diperlukan untuk menjalankan
algoritma tersebut atau ruang memori yang diperlukan
untuk struktur datanya terlalu besar
Kemangkusan algoritma diukur dari berapa jumlah waktu
dan ruang (space) memori yang diperlukan untuk
menjalankannya.
Algoritma yang mangkus adalah yang meminimumkan
kebutuhan waktu dan ruang memori.
TINJAUAN
Contoh: algoritma menentukan
berapa banyak himpunan bagian
suatu himpunan yang
mengandung n elemen, akan
membutuhkan waktu 2n, n
bilangan kardinal.
Kebutuhan waktu suatu algortima
biasanya dihitung dalam satuan
detik (second), sedangkan ruang
memori yang digunakannya
dapat dihitung dalam satuan byte
TINJAUAN
Kebutuhan waktu dan ruang suatu algoritma
bergantung pada ukuran masukan, yang secara
khusus adalah jumlah data yang diproses.
Ukuran masukan disimbolkan dengan n
Waktu/ruang yang dibutuhkan oleh algoritma
dinyatakan sebagai fungsi dari n, f(n).
Bila n meningkat, maka kebutuhan sumber daya
waktu/ruang yang dibutuhkan juga meningkat.
Seberapa besar peningkatan sumber daya itu
menentukan apakah algoritmanya mangkus
atau tidak.
MANAKAH YANG DIPILIH?
Menggunakan algoritma yang waktu eksekusinya cepat
dengan komputer yang standar.
Ataukah
Menggunakan algoritma yang tidak cepat dengan
komputer yang cepat.
Misalkan untuk menyelesaikan sebuah masalah
telah tersedia :
algoritma dengan waktu eksekusi eksponensial (2n).
komputer yang mampu menjalankan suatu program
dalam waktu 10-4 detik.
Dengan algoritma dan komputer tersebut,
kecepatan eksekusi suatu program dengan
algoritmanya menjadi 2n x 10-4 detik
MANAKAH YANG DIPILIH?
Jumlah Waktu eksekusi
Masukan (n) (2n x 10-4 detik)
10 210 x 10-4 = 1024 x 10-4 0,1 detik
20 220 x 10-4 = 1.048.576 x 10-4
= 104,8576 detik 2 menit
30 230 x 10-4 = 1.073.741.824 x 10-4
= 107.374,1824 detik > 1 hari
38 238 x 10-4 = 274.877.906.944 x 10-4
= 27.487.790,6944 detik 1 tahun
MANAKAH YANG DIPILIH?
Jadi dalam 1 tahun hanya mampu mengeksekusi 38
masukan.
Jika digunakan komputer dengan kecepatan 100 kali
(menjadi 10-6). Dengan algoritma yang sama kita
sekarang dapat menyelesaikan masalah untuk masukan
sebanyak n dalam waktu 2n x 10-6 detik. Dalam 1 tahun
hanya mampu menyelesaikan masukan sebanyak 45.
Secara umum, jika sebelumnya kita mampu
menyelesaikan persoalan dengan masukan sebanyak n
dalam selang waktu tertentu, komputer baru itu akan
dapat menyelesaikan persoalan dengan masukan paling
banyak n + 7 dalam waktu yang sama.
MANAKAH YANG DIPILIH?
Sekarang kita menemukan sebuah algoritma untuk
menyelesaikan masalah yang sama dalam waktu orde
kubik (n3).
Dengan komputer yang pertama, algoritma ini dapat
menyelesaikan masalah dengan masukan sebanyak n
dalam waktu n3 x 10-4 detik. Dalam waktu sehari dapat
menyelsaikan masukan sebanyak 900, dan dalam waktu 1
tahun komputasi ukuran masukan dapat mencapai 6.800
lebih.
Bahkan dengan komputer kedua, jumlah masukan yang
dapat diproses selama 1 tahun komputasi menjadi lebih
banyak lagi, yaitu 31.500 lebih.
Algoritma kedua (orde kubik) lebih mangkus yang berarti
lebih bagus dari algoritma pertama (orde eksponensial)
BAGAIMANA CARA MENGUKUR
KEBUTUHAN WAKTU ALGORITMA?
Mengeksekusi langsung algoritma tersebut
pada sebuah komputer. Lalu dihitung berapa
lama durasi waktu yang diperlukan untuk
menyelesaikan sebuah persoalan dengan n
yang berbeda-beda.
Keakuratan waktu eksekusi algoritma dapat
diperoleh dengan tidak menghitung kebutuhan
waktu untuk menampilkan antarmuka
(interface) program, operasi masukan dan
keluaran (baca, tulis), dan sebagainya. Jadi,
benar-benar yang dihitung adalah kebutuhan
waktu untuk bagian algoritma yang inti saja.
BAGAIMANA CARA MENGUKUR
KEBUTUHAN WAKTU ALGORITMA?
Misalnya untuk masalah menghitung rata-rata
dari n buah data bilangan bulat. Maka kita
mengasumsikan data masukan sudah dibaca
dan disimpan dalam elemen-elemen larik. Jadi,
kita hanya memperhatikan bagian perhitungan
rata-ratanya saja.
Selisih waktu antara sebelum pemanggilan
prosedur dan sesudah pemanggilan prosedur
merupakan kebutuhan waktu aktual untuk
menghitung rata-rata n buah data
BAGAIMANA CARA MENGUKUR
KEBUTUHAN WAKTU ALGORITMA?
Perhitungan kebutuhan waktu algoritma seperti ini kurang dapat
diterima karena 2 alasan :
1. Arsitektur computer yang berbeda menghasilkan waktu yang
berbeda pula untuk melaksanakan opersi-operasi dasar
(penambahan, pengurangan, perkalian, pembagian,
pembandingan, dan sebagainya), sehingga kita tidak memiliki
ukuran waktu yang unik untuk sebuah algoritma.
2. Kebutuhan waktu sebuah algoritma bergantung kepada
compiler bahasa pemrograman yang digunakan.
Compiler yang berbeda akan menerjemahkan program (dalam
bahasa tingkat tinggi) ke dalam bahasa mesin (object code
dalam bahasa tingkat rendah) yang berbeda pula.
Sebagai akibatnya, kode mesin yang berbeda akan
menggunakan ruang memori dan memerlukan waktu
pelaksanaan program yang berbeda pula
JENIS KOMPLEKSITAS
ALGORITMA
Secara teoritis, model abstrak pengukuran ruang/waktu
harus independen dari pertimbangan mesin dan compiler
apapun.
Besaran yang dipakai untuk menerangkan model abstrak
pengukuran waktu/ruang ini adalah kompleksitas
algoritma.
Ada dua macam kompleksitas algoritma, yaitu
Kompleksitas waktu.
Kompleksitas waktu diekspresikan sebagai jumlah tahapan
komputasi yang dibutuhkan untuk menjalankan algoritma sebagai
fungsi dari ukuran masukan n.
Kompleksitas ruang.
Kompleksitas ruang diekspresikan sebagai jumlah memori yang
digunakan oleh struktur data yang terdapat di dalam algoritma
sebagai fungsi dari ukuran masukan n.
Terminologi Kompleksitas Waktu /
Ruang
Terminologi yang diperlukan dalam membahas kompleksitas waktu
dan kompleksitas ruang suatu algoritma adalah :
Ukuran besaran masukan data untuk suatu algoritma, n.
Contoh:
Algoritma pengurutan elemen-elemen larik, n adalah jumlah elemen
larik.
Algoritma perkalian elemen matriks, n2 adalah ukuran matriks n x n.
Pada beberapa kasus, ukuran masukan lebih tepat menggunakan dua
buah besaran, misalnya jika masukan algoritma adalah graf, maka
ukuran masukan adalah jumlah simpul (node) dan jumlah sisi (link).
Kompleksitas Waktu, T(n) adalah jumlah operasi yang dilakukan
untuk melaksanakan algoritma sebagai fungsi dari ukuran masukan n.
Kompleksitas Ruang, S(n) adalah ruang memori yang dibutuhkan
algoritma sebagai fungsi dari ukuran masukan n.
Menghitung Kompleksitas Waktu
Langkah yang dilakukan untuk menghitung kompleksitas
waktu adalah
1. Memahami kegunaan / tujuan secara keseluruhan dari
algoritma.
Kegunaan algoritma berguna untuk memahami
kerangka logika langkah-langkah algoritma.
Kerangka logika langkah-langkah dapat diketahui
dengan lebih baik dan lebih mudah dengan cara
mengkonversinya ke dalam diagram alir (flowchart)
Kegunaan algoritma dapat diketahui
dari penjelasan / uraian algoritma yang terdapat di bawah judul
algoritma.
dengan cara menelusuri (scanning) algoritma tersebut dengan
sejumlah data yang valid.
Algoritma 1
HITUNGRERATA
procedure HITUNGRERATA (input integer A(1:n), output real r)
// Menghitung nilai rata-rata dari sekumpulan elemen larik
integer A(n) = a1, a2, . . ., an-1, an. Nilai rata-rata akan
disimpan di dalam peubah r.//
// Deklarasi //
integer i;
real jumlah;
// Deskripsi //
jumlah <- 0;
i <- 1;
while i n do
jumlah <- jumlah + ai;
i <- i + 1;
repeat;
// i > n //
r <- jumlah / n; // nilai rata-rata //
endHITUNGRERATA;
Algoritma 1
HITUNGRERATA (input integer A(1:n), output real r)
Menghitung Kompleksitas Waktu
Pada algoritma 1; HITUNGRERATA, terdapat kegunaan
algoritma yang tertulis di bawah judul prosedurnya,
yaitu
// Menghitung nilai rata-rata dari
sekumpulan elemen larik integer A(n) =
a1, a2, . . ., an-1, an. Nilai rata-rata
akan disimpan di dalam peubah r.//

2. Menetapkan ukuran masukan.

Jelas bahwa pada algoritma 1; HITUNGRERATA di
atas, ukuran masukan dapat diketahui dengan mudah
dari pernyataan input integer A(1:n) yang
terdapat pada judul prosedurnya, yaitu jumlah elemen
larik A, sebanyak n.
Menghitung Kompleksitas Waktu
3. Menghitung banyaknya operasi yang dilakukan.
Ada banyak jenis operasi dalam sebuah
algoritma:
operasi aritmatika (+, -, /, *, div, mod, dan
sebagainya),
operasi perbandingan,
operasi pembacaan dan penulisan,
pemanggilan prosedur dan sebagainya
Pada algoritma 1; HITUNGRERATA terdapat
banyak operasi yang dilakukan, yaitu:
operasi penugasan / pengisian nilai (dengan operator
<-).
operasi penambahan (dengan operator +).
operasi pembagian (dengan operator /).
Rincian Perhitungan Jumlah Operasi
Algoritma HITUNGRERATA
Operasi pengisisan nilai
jumlah <- 0; 1 kali
i <- 1; 1 kali
jumlah <- jumlah + ai; n kali (karena
berada dalam looping while_do)
i <- i + 1; n kali (karena berada
dalam looping while_do)
r <- jumlah / n; 1 kali
Jumlah seluruh operasi pengisian nilai adalah
t1 = 1 +1 + n + n + 1 = 2n + 3.
Rincian Perhitungan Jumlah Operasi
Algoritma HITUNGRERATA
Operasi Penambahan
jumlah + ai n kali
i + 1 n kali
Jumlah seluruh operasi penambahan adalah
t2 = n + n = 2n.
Operasi Pembagian, jumlah seluruh operasinya, t3 adalah
jumlah/n1 kali
Operasi Perbandingan i n, jumlah seluruh operasinya,
t4 adalah
i n n kali
Jadi, kompleksitas waktu algoritma dihitung berdasarkan
banyaknya jumlah operasi aritmatika, operasi pengisian
nilai dan perbandungan adalah
T(n) = t1 + t2 + t3 + t4 = 3 + 2n + 2n + 1 + n = 5n + 4.
Menentukan Operasi Dasar dari
Algoritma
Idealnya, kita memang harus menghitung
semua operasi yang ada di dalam suatu
algoritma.
Namun, untuk alasan praktis, kita cukup
menghitung jumlah operasi abstrak yang
mendasari suatu algoritma, dan
memisahkan analisisnya dari
implementasi.
Operasi abstrak ini disebut operasi dasar
(basic operation)
Menentukan Operasi Dasar dari Algoritma
Untuk algoritma 1; HITUNGRERATA , operasi dasarnya
adalah operasi penjumlahan elemen-elemen larik, yaitu
jumlah <- jumlah + ai;
yang dilaksanakan sebanyak n kali, yaitu sebanyak
pengulangan (while_do) yang dilakukan. Operasi lainnya
dapat diabaikan (tidak dihitung).
Jika kompleksitas algoritma dihitung berdasarkan jumlah
operasi penjumlahan ini, maka kompleksitas waktu
HITUNGRERATA adalah T(n) = 2n.
Pada algoritma pencarian, operasi abstrak yang
mendasarinya adalah operasi perbandingan x (elemen
yang dicari) dengan elemen-elemen larik. Dengan
menghitung berapa kali operasi perbandingan elemen
untuk tiap-tiap nilai n pada dua buah algoritma pencarian,
akan diperoleh kemangkusan relatif dari kedua buah
algoritma tersebut.
Menentukan Operasi Dasar dari
Algoritma
Pada algoritma pengurutan, operasi dasarnya adalah
operasi perbandingan elemen-elemen larik dan operasi
pertukaran elemen-elemen.
Kedua operasi dasar ini dihitung secara terpisah, karena
jumlah operasi perbandingan tidak sama dengan operasi
pertukaran.
Pada algoritma perkalian dua buah matriks A x B yang
masing-masing berukuran n x n, operasi dasar yang bagus
untuk dipilih adalah operasi penjumlahan dan perkalian.
Kedua operasi dasar ini juga dihitung terpisah.
Pada algoritma evaluasi polinom, p(x) = a0 + a1x + a2x2 + .
. . + an-1xn-1 + anxn, operasi-operasi dasar di dalam
algoritmanya adalah juga operasi penjumlahan dan
perkalian.
Parameter Ukuran Masukan
Hal lain yang harus diperhatikan dalam
menghitung kompleksitas waktu adalah parameter
yang mencirikan ukuran masukan.
Pada algoritma pencarian misalnya, waktu
pencarian tidak hanya bergantung pada ukuran
larik (n), tetapi juga bergantung pada nilai elemen
yang dicari (x).
Sebagai contoh, larik bilangan bulat A(1:128).
Asumsikan elemen-elemen larik sudah terurut.
Jika x = a1, maka waktu pencariannya 128 kali
lebih cepat daripada x = a128 atau jika x tidak
terdapat dalam larik.
Demikian pula jika x = a64, maka waktu
pencariannya kali lebih cepat daripada jika x =
a .
Parameter Ukuran Masukan
Dengan demikian, kompleksitas waktu dibedakan atas tiga macam :
Tmin(n) : kompleksitas waktu untuk kasus terbaik (best case).
Yaitu kebutuhan waktu minimum yang diperlukan sebuah algoritma
sebagai fungsi dari n.
Tmax(n) : kompleksitas waktu untuk kasus terburuk (worst case).
Yaitu kebutuhan waktu maksimum yang diperlukan sebuah algoritma
sebagai fungsi dari n.
Tavg(n) : kompleksitas waktu untuk kasus rata-rata (average case).
Yaitu kebutuhan waktu rata-rata yang diperlukan sebuah algoritma
sebagai fungsi dari n.
Untuk kasus rata-rata ini, biasanya dibuat asumsi bahwa semua
barisan masukan bersifat sama. Misalnya, pada persoalan pencarian
diandaikan bahwa data yang dicari mempunyai peluang yang sama
untuk terletak di dalam larik