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 n22 n+2
Untuk n yang besar, pertumbuhan T(n) akan sebanding dengan n2 dan dengan
mengabaikan suku yang tidak mendominasi kita, maka kita tuliskan
2

T ( n ) =O(n )
Pada infinitesimal asymptotics, Big O digunakan untuk menjelaskan kesalahan dalam
aproksimasi untuk sebuah fungsi matematika, sebagai contoh
2

x x
e x =1+ + +O ( x3 ) , x 0
1 2
Kesalahannya memiliki selisih
x x2
e x (1+ + )
1 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.

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)
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)
3

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
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.
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:
n1

T ( n ) =( n1 )+ ( n2 ) ++ 2+1= ni
i=1

n ( n1 )
2
=O(n )
2

Berarti kompleksitasnya secara simptotik adalah O(n2).

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

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.
n1

T ( n ) =1+ 2+ +n1=
i=1

n ( n1 )
=O(n2)
2

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

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

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 1
Di mana W(h)

= waktu untuk mengurutkan U

W(m)

= waktu untuk mengurutkan V

h+m1

= 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:
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 ( n1 ) +n1
Karena T (0)=0 , maka rekurensinya
T ( n ) =T ( n1 )+ n1
T ( 0)=0

Solusi

dari

rekurens

tersebut

T ( n) =

adalah

kompleksitas kasus terburuk Quick Sort adalah T ( n ) =

2.

n(n1)
,
2

sehingga

n(n1)
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.

n
n log

n=O

Sehingga didapat:
T ( n ) =2T

3.

( n2 )+ cn=na+ cn log

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 :
n

A ( n )= 1
p =1

1
[ A ( p1 ) + A (n p)] +(n1)
n

p=1

p=1

1 1n [ A ( p1 )+ A (n p) ]+(n1)=2 A( p1)
10

A ( n )=

Sehingga,

2
A ( p1 )
n p=1
n

nA ( n )=2 A ( p1)+n(n1)
p=1

Bila n adalah n-1, maka

n

( n1 ) A ( n1 )=2 A ( p1 ) +n ( n1 )( n2 )
p=1

Dengan men-substrak dua persamaan tersebut, didapat

A (n) A (n1) 2(n1)
=
+
n+1
n
n (n+1)
A (n)
a
=
n
Misalkan
n+ 1

an =an1 +

maka akan didapat rekurens:

2 ( n1 )
untuk n>0
n ( n+1 )

an =0
Solusi dari rekurens tersebut adalah
2
ln

n
log
A ( n ) ( n+1 ) 2 lnn=( n+1 ) 2

11

an 2 ln n

yang mengakibatkan

n
n log

n O
1.38 ( n+1 ) log

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).

12

Merge Sort dan Quick Sort mempunyai batasan yang sama yaitu

n
n log ,
O

tetapi dengan basis log yang berbeda. Khusus Quick Sort memiliki
2
kompleksitas O(n ) untuk kasus terburuk.

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-contoharray.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-algoritmaimplementasi-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

15