Professional Documents
Culture Documents
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
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
2.1
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
(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
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
2.2
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
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