Algoritma adalah urutan langkah-langkah logis penyelesaian masalah yang

disusun secara sistematis dan logis. Sebuah algoritma tidak saja harus benar, tetapi

juga harus efisien. Algoritma yang bagus adalah algoritma yang efektif dan efisien.

Untuk dapat mengetahui seberapa efisien suatu algoritma, dipakailah teori

kompleksitas algoritma sebagai dasar kajian. Kompleksitas terbagi atas dua, yaitu

kompleksitas waktu dan kompleksitas ruang.

Kompleksitas Waktu, T(n), adalah jumlah operasi yang dilakukan untuk

melaksanakan algoritma sebagai fungsidari ukuran masukan n. Maka, dalam

mengukur kompleksitas waktu dihitunglah banyaknya operasi yang dilakukan oleh

algoritma. Idealnya, kita memang harus menghitung semua operasi yang ada dalam

suatu algoritma. Namun, untuk lasan praktis, cukup menghitung jumlah operasi

abstrak yang mendasari suatu algoritma. Operasi abstrak ini disebut Operasi Dasar.

Pada algoritma pengurutan, terutama pada pengurutan dengan perbandingan,

operasi dasar adalah operasioperasi perbandingan elemen-elemen suatu larik dan

operasi pertukaran elemen. Kedua hal itu dihitung secara terpisah, karena jumlah

keduanya tidaklah sama. Biasanya kompleksitas algoritma dinyatakan secara

asimptotik dengan notasi big-O. Jika kompleksitas waktu untuk menjalankan suatu

algoritma dinyatakan dengan T(n), dan memenuhi T(n) ≤ C(f(n)) untuk n ≥ n0, maka

kompleksitas dapat dinyatakan dengan

T(n) = O(f(n)).

Terdapat 2 jenis penggunaan notasi Big O, yaitu :1

1. Infinite asymptotics

2. Infinitesimal asymptotics

Perbedaan kedua jenis penggunaan notasi ini hanya pada aplikasi. Sebagai contoh,

pada infinite asymptotics dengan persamaan

T (n )=2 n2−2n+2

Untuk n yang besar, pertumbuhan T(n) akan sebanding dengan n2 dan dengan

mengabaikan suku yang tidak mendominasi kita, maka kita tuliskan

T (n )=O(n2)

Pada infinitesimal asymptotics, Big O digunakan untuk menjelaskan kesalahan dalam

aproksimasi untuk sebuah fungsi matematika, sebagai contoh

ex=1+ x1+ x2

2+O ( x3 ) , x→ 0

Kesalahannya memiliki selisih

ex−(1+ x1+ x2

2)

A. Kompleksitas Bubble Sort

Kompleksitas Algoritma Bubble Sort dapat dilihat dari beberapa jenis kasus,

yaitu worst-case, average-case, dan best-case.

1. Kondisi Best-Case

Dalam kasus ini, data yang akan disorting telah terurut sebelumnya sehingga

proses perbandingan hanya dilakukan sebanyak (n-1) kali, dengan satu kali pass.

2

Proses perbandingan dilakukan hanya untuk memverifikasi keurutan data. Contoh

Best-Case dapat dilihat pada pengurutan data “1 2 3 4” di bawah ini.

Pass Pertama

(1 2 3 4) menjadi (1 2 3 4)

(1 2 3 4) menjadi (1 2 3 4)

(1 2 3 4) menjadi (1 2 3 4)

Dari proses di atas, dapat dilihat bahwa tidak terjadi penukaran posisi satu

kalipun, sehingga tidak dilakukan pass selanjutnya. Perbandingan elemen dilakukan

sebanyak tiga kali. Proses perbandingan pada kondisi ini hanya dilakukan sebanyak

(n-1) kali. Persamaan Big-O yang diperoleh dari proses ini adalah O(n). Dengan kata

lain, pada kondisi Best-Case algoritma Bubble Sort termasuk pada algoritma lanjar.

2. Kondisi Worst-Case

Dalam kasus ini, data terkecil berada pada ujung array. Contoh Worst-Case

dapat dilihat pada pengurutan data “4 3 2 1” di bawah ini.

Pass Pertama

(4 3 2 1) menjadi (3 4 2 1)

(3 4 2 1) menjadi (3 2 4 1)

(3 2 4 1) menjadi (3 2 1 4)

Pass Kedua

(3 2 1 4) menjadi (2 3 1 4)

(2 3 1 4) menjadi (2 1 3 4)

(2 1 3 4) menjadi (2 1 3 4)3

Pass Ketiga

(2 1 3 4) menjadi (1 2 3 4)

(1 2 3 4) menjadi (1 2 3 4)

(1 2 3 4) menjadi (1 2 3 4)

Pass Keempat

(1 2 3 4) menjadi (1 2 3 4)

(1 2 3 4) menjadi (1 2 3 4)

(1 2 3 4) menjadi (1 2 3 4)

Dari langkah pengurutan di atas, terlihat bahwa setiap kali melakukan satu

pass, data terkecil akan bergeser ke arah awal sebanyak satu step. Dengan kata lain,

untuk menggeser data terkecil dari urutan keempat menuju urutan pertama,

dibutuhkan pass sebanyak tiga kali, ditambah satu kali pass untuk memverifikasi.

Sehingga jumlah proses pada kondisi best case dapat dirumuskan sebagai berikut.

Jumlah proses = n2+n

Dalam persamaan di atas, n adalah jumlah elemen yang akan diurutkan.

Sehingga notasi Big-O yang didapat adalah O(n2). Dengan kata lain, pada kondisi

worst-case, algoritma Bubble Sort termasuk dalam kategori algoritma kuadratik.

3. Kondisi Average-Case

Pada kondisi average-case, jumlah pass ditentukan dari elemen mana yang

mengalami penggeseran ke kiri paling banyak. Hal ini dapat ditunjukkan oleh proses

pengurutan suatu array, misalkan saja (1 8 6 2). Dari (1 8 6 2), dapat dilihat bahwa

4

yang akan mengalami proses penggeseran paling banyak adalah elemen 2, yaitu

sebanyak dua kali.

Pass Pertama

(1 8 6 2) menjadi (1 8 6 2)

(1 8 6 2) menjadi (1 6 8 2)

(1 6 8 2) menjadi (1 6 2 8)

Pass Kedua

(1 6 2 8) menjadi (1 6 2 8)

(1 6 2 8) menjadi (1 2 6 8)

(1 2 6 8) menjadi (1 2 6 8)

Pass Ketiga

(1 2 6 8) menjadi (1 2 6 8)

(1 2 6 8) menjadi (1 2 6 8)

(1 2 6 8) menjadi (1 2 6 8)

Dari proses pengurutan di atas, dapat dilihat bahwa untuk mengurutkan

diperlukan dua buah passing, ditambah satu buah passing untuk memverifikasi.

Dengan kata lain, jumlah proses perbandingan dapat dihitung sebagai berikut.

Jumlah proses = x2+x

Dalam persamaan di atas, x adalah jumlah penggeseran terbanyak. Dalam hal

ini, x tidak pernah lebih besar dari n. Jadi, dapat disimpulkan bahwa notasi big-O nya

adalah O(n2). Dengan kata lain, pada kondisi average case algoritma Bubble Sort

termasuk dalam algoritma kuadratik.5

Adapun grafik efisiensi bubble sort dapat dilihat pada tabel dibawah ini:

Gambar 1. Grafik Kompleksitas Bubble Sort

B. Kompleksitas Selection Sort

Algoritma di dalam Selection Sort terdiri dari kalang bersarang. Dimana

kalang tingkat pertama (disebut pass) berlangsung N-1 kali. Di dalam kalang kedua,

dicari elemen dengan nilai terkecil. Jika didapat, indeks yang didapat ditimpakan ke

variabel min. Lalu dilakukan proses penukaran. Begitu seterusnya untuk setiap Pass.

Pass sendiri makin berkurang hingga nilainya menjadi semakin kecil. Berdasarkan

operasi perbandingan elemennya:

T (n )=(n−1 )+(n−2 )+…+2+1=∑i=1

n−1

n−i

¿ n (n−1 )2

=O(n2)

Berarti kompleksitasnya secara simptotik adalah O(n2).

Adapun grafik efisiensi selection sort dapat dilihat pada tabel dibawah ini:

6

Gambar 2. Grafik Kompleksitas Selection Sort

Pengurutan model ini tergolong buruk dan lebih baik dihindari

penggunaannya, terutama untuk penanganan tabel dengan lebih dari 1000 elemen.

C. Kompleksitas Insertion Sort

Algoritma Insertion Sort juga terdiri dari 2 kalang bersarang. Dimana terjadi

N-1 Pass (dengan N adalah banyak elemen struktur data), dengan masing-masing

Pass terjadi i kali operasi perbandingan. i tersebut bernilai 1 untuk Pass pertama,

bernilai 2 untuk Pass kedua, begitu seterusnya hingga Pass ke N-1.

T (n )=1+2+…+n−1=∑i=1

n−1 n (n−1 )2

=O(n2)

Secara Kompleksitas, selection sort dan insertion sort mempunyai Big-Oh

yang sama. Walaupun begitu, insertion sort sebenarnya lebih mangkus. Perhatikan

gambar berikut:

7

Gambar 3. Grafik Kompleksitas Insertion Sort

D. Kompleksitas Merge Sort

Dalam algoritma ini, jumlah perbandingan yang terjadi bergantung pada h dan

m. Kondisi terburuk terjadi ketika perulangan berhenti, karena salah satu indeks,

sebut saja i, telah mencapai titik berhentinya dimana indeks lain j telah mencapai m –

1, lebih rendah 1 dari titik berhentinya. Sehingga, W(h,m) = h + m – 1

Jumlah keseluruhan perbandingan adalah jumlah banyaknya perbandingan

dalam pemanggilan rekursif merge sort dimana U sebagai input, banyaknya

perbandingan dalam pemanggilan rekursif merge sort dimana V sebagai input, dan

banyaknya perbandingan di top-level pemanggilan merge. Sehingga,

W(n) = W(h) + W(m) + h + m – 18

Di mana W(h) = waktu untuk mengurutkan U

W(m) = waktu untuk mengurutkan V

h + m – 1 = waktu untuk bergabung

Pertama, kita menganalisa kasus diaman n adalah eksponen dari 2. Dalam

kasus ini,

__

__ __

__ __

Ekspresi untuk W(n) menjadi

__ __

__

Ketika besar input adalah 1, kondisi pemberhentian terpenuhi dan tak ada

penggabungan. Sehingga, W(1) adalah 0.

Solusi dari rekurens tersebut adalah Merge Sort akan selalu membagi dua tiap

sub-arraynya hingga mencapai basis, sehingga kompleksitas dari algoritma Merge

Sort, berlaku untuk semua kasus (Worst Case = Best Case = Average Case).

E. Kompleksitas Quick Sort

Kebutuhan waktu dari quicksort bergantung pada pembuatan partisi, seimbang

atau tidak, yang bergantung juga pada elemen yang digunakan sebagai pivot. Dalam

menghitung kompleksitas ini, perlu dilihat pula perhitungan recurrence, karena

terdapat fungsi rekursif untuk penyelesaian sub-masalah.

Terdapat 3 jenis kompleksitas waktu dari quicksort:9

1. Kasus terburuk (worst case),

Kasus terburuk untuk Quick Sort terjadi jika array dalam keadaaan telah

terurut takmenurun. Bila array telah terurut, maka tak ada elemen lebih kecil

dari pivot yang dipindahkan ke sebelah pivot. Sehingga,

T (n )=T (0 )+T (n−1 )+n−1

Karena T (0)=0, maka rekurensinya

T (n )=T (n−1 )+n−1

T (0)=0

Solusi dari rekurens tersebut adalah T (n )=n(n−1)2

, sehingga kompleksitas

kasus terburuk Quick Sort adalah T (n )=n(n−1)2

∈O(n2)

2. Kasus terbaik (best case), yaitu terjadi bila terbentuk partisi dengan dengan

komposisi seimbang, dengan ukuran masing-masing tidak lebih dari n/2.

Sehingga didapat: T (n )=2 T ( n2 )+cn=na+cn logn=O¿¿

3. Kasus rata-rata (average case), yaitu terjadi dari perimbangan pivot antara terbaik

dan terburuk, yang dalam prakteknya lebih mendekati kasus terbaik ketimbang

terburuk. Waktu kompleksitas untuk kasus rata-rata dapat ditentukan dengan

menyelesaikan rekurens ini :

A (n )=∑p=1

n

1 1n [ A ( p−1 )+ A (n−p) ]+(n−1)

10

∑p=1

n

1 1n [ A ( p−1 )+ A(n−p)]+(n−1)=2∑

p=1

n

A ( p−1)

Sehingga, A (n )=2n ∑

p=1

n

A ( p−1 )

nA (n )=2∑p=1

n

A ( p−1)+n (n−1)

Bila n adalah n-1, maka

(n−1 ) A (n−1 )=2∑p=1

n

A ( p−1 )+n (n−1 ) (n−2 )

Dengan men-substrak dua persamaan tersebut, didapat

A (n)n+1

=A (n−1)

n+

2(n−1)n(n+1)

Misalkan an=A (n)n+1

maka akan didapat rekurens:

an=an−1+2 (n−1 )n (n+1 )

untuk n>0

an=0

Solusi dari rekurens tersebut adalah an≈ 2 ln nyang mengakibatkan

A (n ) ≈ (n+1 ) 2 ln n=(n+1 )2¿

≈ 1.38 (n+1 ) log n∈O ¿¿

11

Gambar 4. Grafik Kompleksitas Bubble Sort

F. Kesimpulan

Algoritma BubbleSort memiliki kelemahan, yaitu kompleksitas algoritma

O(n2) pada average case dan worst case, sehingga menjadikan algoritma ini

tidak efektif dalam pengurutan.

Khusus untuk selection sort dapat disimpulkan bahwa :

a. Kompleksitas selection sort relatif lebih kecil.

b. Kompleksitas algoritma selection sort adalah O(n2).

c. Tidak ada Best Case dan Worst Case karena O(n2) berlaku sama.

d. Pada dasarnya Selection Sort merupakan algoritma yang tidak stabil.

Insertion Sort juga mempunyai O(n2). Insertion Sort juga sudah memiliki

alternatif algoritma yang ber-O(n log n).

Merge Sort dan Quick Sort mempunyai batasan yang sama yaitu O ¿, tetapi

dengan basis log yang berbeda. Khusus Quick Sort memiliki kompleksitas

O(n2) untuk kasus terburuk.

12

Berikut adalah grafik perbandingan kompleksitas beberapa algoritma sort:

Gambar 5. Grafik Perbandingan Kompleksitas Bebebrapa Algoritma Sort

13

DAFTAR PUSTAKA

Pucanglaban, Cah. 2009. Metode Pengurutan Data dan Contoh Array. http://fullsearching.blogspot.com/2009/08/metode-pengurutan-data-dan-contoh-array.html. Diakses tanggal 19 Maret 2012.

Putra, Made EW. 2009. Perbandingan Algoritma Pengurutan Merge Sort, Quick Sort dan Heap Sort Dilihat dari Kompleksitasnya. Bandung: Sekolah Teknik Elektro dan Informatika, ITB.

Rheinadi, Ryan. 2009. Analisis Algoritma Bubble Sort. Bandung: Sekolah Teknik Elektro dan Informatika, ITB.

Said, Fairuz. 2009. Struktur Data – Algoritma & Implementasi Buble Sort dalam Bahasa C/C++. http://fairuzelsaid.wordpress.com/2009/12/28/struktur-data-algoritma-implementasi-buble-sort-dalam-bahasa-c/. Diakses tanggal 18 Maret 2012.

Tjaru, Setia Negara. 2009. Kompleksitas Algoritma Pengurutan Selection Sort dan Insertion Sort. Bandung: Teknik Informatika ITB.

Triono, Puji. 2010. Analisis Perbandingan Algoritma Sorting dan Searching. Yogyakarta: Fakultas Teknologi Industri Universitas Ahmad Dahlan.

14