Kompleksitas Algoritma Quick Sort

Abstract Makalah ini membahas kompleksitas dari algoritma pengurutan Quick Sort. Suatu masalah dapat ditangani dengan algoritma yang berbeda-beda. Agoritma tersebut tidaklah harus benar tetapi juga harus efisien. Keefisienan tersebut diukur dari waktu eksekusi dan kebutuhan ruang memori. Algrotitma yang efisien merupakan algoritma yang meminimumkan waktu eksekusi dan ruang memori

BAB I Konsep Algoritma Quick Sort

Versi utama dari Quick Sort ditemukan oleh C. A. R. Hoare pada tahun 1960 dan secara resmi diperkenalkan pada tahun 1962. Quick Sort merupakan algoritma pengurutan yang berbasiskan Divide and Conquer. Quick Sort disebut juga dengan partition exchange sort. Disebut demikian karena konsepnya membuat partisi-partisi dan pengurutan dilakukan per partisi. Algortima Quick Sort terbukti memiliki average behaviour yang terbaik diantara metode pengurutan yang ada. Teknik mempartisi tabel : 1. Pilih x elemen dari {a1, a2, , an} sebagai elemen pivot 2. Pindai tabel dari kiri sampai ditemukan elemen yang lebih besar dari x (ap x) 3. Pindai tabel dari kanan sampai ditemukan elemen yang lebih kecil dari x (aq x) 4. Pertukarkan ap aq 5. Ulangi langkah 2 dari posisi p+1, dan langkah 3 dari posisi q-1, sampai kedua pemindai bertemu ditengah tabel Dalam algortima Quick Sort, pemilihan pivot adalah hal yang menentukan algoritma tersebut akan memberikan performa terbaik atau terburuk. Beberapa cara pemilihan pivot : 1. Pivot elemen pertama, elemen terakhir, elemen tengah tabel. Cara ini bagus jika

elemen tabel tersususun acak, tetapi tidak bagus jika elemen tabel semula sudah terurut 2. Pivot secara acak dari salah satu elemen tabel. Cara ini baik, tetapi mahal, sebab memerlukan biaya pembangkitan prosedur acak. Lagipula cara ini tidak megurangi kompleksitas waktu algortima pada kasus terburuk 3. Pivot merupakan elemen median tabel. Cara ini menghasilkan dua bagian tabel yang berukuran seimbang. Cara ini memberikan kompleksitas waktu yang minimum. Masalahnya, mencari median dari tabel yang belum terurut permasalahn tersendiri Quick Sort adalah algortima yang banyak dipilih pada kasus apapun karena tidak sulit dalam implementasinya dan menghabiskan sedikit memori selama eksekusi.

BAB II

ALGORTIMA QUICK SORT

2.1

Algoritma Quick Sort Pseudo-code Quick Sort

Procedure QuickSort (input/output a : array [1..n] of integer, input i,j : integer ) { Mengurutkan table a[i .. j]dengan algoritma quick sort. Masukkan : Tabel a[i .. j]yang sudah terdefinisi elemen-elemennya. Keluaran : Tabel a[i .. j]yang terurut menaik. } Deklarasi : k : integer; Algoritma : If (i < j) then Partisi(a, i, j, k) QuickSort (a, i, k) QuickSort (a, k+1, j) Endif { Ukuran (a) > 1 }

Procedure Partisi (input/output a : array[1..n] of integer, input i, j : integer, output q : integer) { Membagi tabel a[i..j] menjadi upatabel a[i..q] dan a[q+1..j] Keluaran upatabel a[i..q] dan upatabel a[q+1..j] Sedemikian sehingga elemen tabel a[i..q] lebih kecil dari elemen tabel a[q+1..j] } Deklarasi : Pivot, temp : integer Algoritma :

Pivot <- A[(i+j) div 2] { pivot = elemen tengah } p <- i q <- j repeat while a[p] < pivot do p <- p + 1 endwhile { Ap >= pivot } while a[q] > pivot do q <- q 1 endwhile { Aq >= pivot } if (p <= q) then { pertukarkan a[p] dengan a[q]} temp <- a[p] a[p] <- a[q] a[q] <- temp { tentukan awal pemindaian berikutnya} p <- p+ 1 q <- q - 1 endif until p > q Analisis Misalkan table yang akan di urutkan sebagai berikut : 12 5 7 2 9

Langkah langkah pempartisian table :

(i) 12 P (ii) dan (iii) 12 P (iv) 2 P (ii) dan (iii) 2 (p = q, berhenti) Hasil partisi pertama adalah : Kiri : (< 12 ) 2 5 7 5 7 p ; pivot ; q 12 9 5 7 12 q 9 5 7 pivot 2 q 9 5 7 pivot 2 9 q

Kanan : (>= 12 ) 12 9

Jika dilanjutkan. Maka prosesnya adalah sebagai berikut : - Rekursif untuk table partisi sebelah kiri a 2 5 Langkah langkah pempartisian table (i) 7

2 p (ii) dan (iii) 2 (p = q, berhenti)

5 pivot

7 q

5 p; pivot; q

- Rekursif untuk table partisi sebelah kanan b 12 9 Langkah langkah pempartisian table (i) 12 p; pivot (ii) dan (iii) 9 p; pivot (iv) 9 pivot; q 12 p 12 q 9 q

(p > q, berhenti) 2 5 Tabel telah terurut menaik. 7 9 12

2.2

Algoritma Randomize Quick Sort Random pivot/partisi

Randomized-Partition(A, p, r) i <- Random(p, r) exchange(A[r], A[i]) return Partition(A, p, r) Running Time T(n) = O(n) Random Quicksort Randomized-Quicksort(A, p, r) if p < r then q <- Randomized-Partition(A, p, r) Randomized-Quicksort(A, p, q - 1) Randomized-Quicksort(A, q + 1, r) Running Time T(n) = O(n log n)

Implementasi progam procedure QuickSort(A[1....N] array of integer, Awal, Akhir: Integer); var LT, RT, Pivot as Integer; begin //randomized pivot while (Awal < Akhir) do begin RT= Awal + Random(Akhir - Awal + 1); LT = (Awal + Akhir) div 2; Exchange(RT, LT); repeat //repeat randomized pivot repeat Dec(RT) until A[RT] <= Pivot; repeat Inc(LT) until A[LT] >= Pivot; if (LT < RT) then Exchange(LT, RT); // RT = posisi acak // LT = posisi tengah // tukarkan tengah dan acak

until LT >= RT; if (Awal < RT) then QuickSort(A[], Awal, RT); Awal = RT + 1; end; end;

Analisis Random Partition Menentukan posisi acak partisi / pivot exchange(A[r], A[i]) => menukarkan posisi partisi tengah A[r] dengan posisi partisi acak A[i]

Analisis Random Partition Quicksort 1. Memilih secara random partisi pada setiap perulangan akan memudahkan

untuk analisis 2. Dengan memilih secara random maka hal ini akan memastikan bahwa

elemen pivot/partisi adalah salah satu dari elemen input. 3. Pengacakan pivot berguna untuk menaikkan Algoritma untuk kasus

terburuk (karena alasan no 4). 4. Dengan cara mengacak pivot maka kasus terburuk akan tetap ada tetapi

kita hampir tidak mengetahuinya. 5. Tingkat efesiensi sama dengan Quicksort partisi tepat tengah tengah

untuk jumlah data kecil (data <=1000), tetapi mempunyai kecepatan yang lebih dan tingkat kedalaman rekursif untuk jumlah data besar(data >= 10000)
6.

Kecepatan penyelesaian tidak hanya ditentukan oleh input tetapi juga oleh

nilai-nilai yang dihasilkandari acak-nomor partisi

BAB III PENUTUP

Algoritma Quick Sort dapat kita ketahui sebagai algoritma yang handal dalam melakukan pengurutannya dari besarnya waktu asimptotik yang diperlukan apabila diberikan n buah masukan. Dimana kompleksitas algoritma dari algoritma ini memiliki 3 kasus yaitu O(n 2log n) untuk kasus terbaik (Best Case), O(n2) untuk kasus terburuk (Worst Case), dan O(n 2log n) untuk kasus rata-rata (Average Case). Kompleksitas tersebut dipengaruhi karena pemilihan pivot. Oleh karena itu proses pemilihan pivot perlu dipertimbangkan. Pivot yang terkadang digunakan yaitu elemen tengah dari tabel yang akan diurut.

DAFTAR PUSTAKA
Munir, Rinaldi. 2006. Diktat Kuliah IF2153 Matematika Diskrit Edisi Keempat. Departemen Teknik Informatika, Institut Teknologi Bandung. Munir, Rinaldi. 2007. Diktat Kuliah IF2251 Strategi Algoritmik, Departemen Teknik Informatika, Institut Teknologi Bandung. Moh. Sjukani. 2007. Struktur Data (Algoritma & Struktur Data 2) dengan C, C++,Mitra Wacana Media.Jakarta http://www.just.edu.jo/~basel/algorithms/Algo%20Slides/algo_ch7_quick_sort.pdf http://personal.denison.edu/~havill/TuesdaysF07/latex/paper.pdf http://www.bowdoin.edu/~ltoma/teaching/cs231/fall07/Lectures/quicksort.pdf

http://www.cs.duke.edu/~reif/courses/alglectures/skiena.lectures/lecture5.pdf