Quicksort
![]() Visualisasi Algoritme Quicksort. Garis horisontal merupakan nilai sumbu. | |
Quicksort | |
---|---|
Kelas | Algoritme Sorting |
Waktu | O(n2) |
Kasus rata-rata | O(n log n) |
Kasus terburuk | O(n log n) |
Quicksort merupakan Algoritme pengurutan yang dikembangkan oleh Tony Hoare. performa rata-rata pengurutan O(n log n) untuk mengurutkan n item. Algoritme ini juga dikenal sebagai Partition-Exchange Sort atau disebut sebagai Sorting Pergantian Pembagi. Pada kasus terburuknya, algoritme ini membuat perbandingan O(n2), walaupun kejadian seperti ini sangat langka. Quicksort sering lebih cepat dalam praktiknya daripada algoritme urut gabung dan heapshort.[1] Dan juga, urutan dan referensi lokalisasi memori quicksort bekerja lebih baik dengan menggunakan cache CPU, jadi keseluruhan sorting dapat dilakukan hanya dengan ruang tambahan O(log n).[2]
Quicksort merupakan sorting pembanding dan pada implementasi efisien tidak merupakan algoritme sorting yang stabil.
Algoritme
[sunting | sunting sumber]Quicksort merupakan Algoritme Pembagi. Pertama quicksort membagi list yang besar menjadi dua buah sub list yang lebih kecil: element kecil dan element besar. Quicksort kemudian dapat menyortir sub list itu secara rekursif.
Langkah-Langkah pengerjaannya ialah:
- Ambil sebuah elemen, yang disebut dengan pivot, pada sebuah daftar.
- Urutkan kembali sebuah list sehingga elemen dengan nilai yang kecil dari pivot berada sebelum pivot, sedangkan seluruh element yang memiliki nilai yang lebih besar dari pivot berada setelahnya (nilai yang sama dapat berada pada pivot setelahnya). Setelah pemisahan, pivot berada pada posisi akhirnya. Operasi ini disebut Partition.
- Sub list kemudian disortir secara recursif dari elemen yang lebih kecil dan sub list dari elemen yang lebih besar.
Kasus dasar dari rekusrif ialah list dari besaran nol atau satu, yang tidak perlu untuk di sorting.
Versi Sederhana
[sunting | sunting sumber]Dalam Pseudocode sederhana, Algoritmanya dapat dinyatakan sebagai berikut:
function quicksort('array')
if length('array') ≤ 1
return 'array' // an array of zero or one elements is already sorted
select and remove a pivot value 'pivot' from 'array'
create empty lists 'less' and 'greater'
for each 'x' in 'array'
if 'x' ≤ 'pivot' then append 'x' to 'less'
else append 'x' to 'greater'
return concatenate(quicksort('less'), 'pivot', quicksort('greater')) // two recursive calls
![](https://upload.wikimedia.org/wikipedia/commons/thumb/a/af/Quicksort-diagram.svg/200px-Quicksort-diagram.svg.png)
Perlu diperhatikan bahwa kita hanya memeriksa elemen dengan membandingkan mereka pada elemen yang lain. Prosedur ini disebuk Sorting Pembandingan. Jenis ini juga merupakan jenis sorting yang stabil (asumsikan bahwa untuk setiap method menerima elemen pada urutan aslinya dan pivot yang dipilih merupakan elemen terakhir dari nilai yang sama).
Kebenaran dari algoritme partisi didasari pada dua argumen berikut:
- Pada setiap iterasi, seluruh elemen diproses selama ini berada pada posisi yang diinginkan: sebelum pivot lebih kurang dari nilai pivot, setelah pivot lebih besar dari nilai pivot (Invarian Loop).
Kebenaran dari keseluruhan algortima dapat dibuktikan dengan penyederhanaan fakta: untuk elemen nol atau satu, algoritme tidak akan mengubah data; untuk jumlah data yang lebih besar, algoritme akan menghasilkan dua bagian, elemen yang kurang dari pivot dan elemen yang lebih besar dari nya, data ini sendiri akan diurutkan secara hipotesis rekursif.
![](https://upload.wikimedia.org/wikipedia/commons/9/9c/Quicksort-example.gif)
![](https://upload.wikimedia.org/wikipedia/commons/thumb/8/84/Partition_example.svg/200px-Partition_example.svg.png)
Versi In-place
[sunting | sunting sumber]Kerugian dari versi sederhana diatas membutuhkan ruang simpan O(n) yang lebih besar, yang sama buruknya seperti merge sort. Memory tambahan yang dibutuhkan dapat juga secara radikal berpengaruh pada kecepatan dan performa cache pada implementasi praktiknya. Terdapat juga versi yang lebih rumit yang menggunakan algoritme partisi in-place dan dapat mencapai urutan lengkap menggunakan ruang O(logn) (tidak dihitung input) pada rata-rata (untuk sekali pemanggilan tumpukan). Kita mulai dengan fungsi partisi:
// left is the index of the leftmost element of the array
// right is the index of the rightmost element of the array (inclusive)
// number of elements in subarray = right-left+1
function partition(array, 'left', 'right', 'pivotIndex')
'pivotValue':= array['pivotIndex']
swap array['pivotIndex'] and array['right'] // Move pivot to end
'storeIndex':= 'left'
for 'i' from 'left' to 'right' - 1 // left ≤ i < right
if array['i'] < 'pivotValue'
swap array['i'] and array['storeIndex']
'storeIndex':= 'storeIndex' + 1
swap array['storeIndex'] and array['right'] // Move pivot to its final place
return 'storeIndex'
Ini merupakan Algoritme Partisi In-Place. algortima ini memisahkan bagian dari array antara index kiri dan kanan secara inklusif, dengan memindahkan seluruh elemen kurang dari Setelah kita memiliki ini, menulis quicksort sendiri ialah mudah:
Setiap pemanggilan rekursif pada fungsi quicksort ini mengurangi besar dari array yang akan diurutkan paling tidak satu elemen, semenjak setiap elemen pada pivotNewIndex diletakkan pada posisi akhirnya. Oleh karena itu, algoritme ini menjamin mengakhiri pemanggilan rekursif pada paling banyak n pemanggilan. Bagaimanapun, versi dari quicksort ini tidak stabil semenjak pengurutan elemen partisi hanya dilakukan pada satu partisi. Pemilihan Pivot[sunting | sunting sumber]Pada setiap versi awal quicksort, elemen yang paling kiri dari partisi akan sering menjadi pilihan sebagai elemen pivot. Sayangnya, ini menyebabkan perilaku worst-case pada array yang telah diurut, yang merupakan penggunaan kasus yang sering dipakai. Masalah ini dengan mudah diselesaikan dengan memilih salah satu dari index acak untuk pivot, memilih indek tengah dari partisi atau (secara khusus untuk partisi panjang) memilih median dari elemen awal, tengah, dan akhir dari partisi untuk pivot (sebagaimana direkomendari oleh Robert Sedgewick.[3][4] Memilih elemen pivot juga rumit dengan dengan kehadiran dari Integer Overflow. Jika indeks batas dari subarray yang diurutkan cukup besar, ungkapan naif untuk indeks tengah, (kiri + kanan)/2, akan menyebabkan luapan dan memberikan indeks pivot yang salah. Masalah ini dapat terselesaikan dengan menggunakan, sebagai contoh, kiri + (kanan-kiri)/2 pada indeks elemen tengah, pada masalah dari aritmetika kompleks. Masalah yang sama muncul pada beberapa metode yang lain dari pemilihan elemen pivot. Optimisasi[sunting | sunting sumber]Dua optimisasi penting lainnya, juga disarankan oleh Robert Sedgewick, sebagai pernyataan yang secara umum diakui, dan digunakan secara luas ialah:[5][6][7]
Paralelisasi[sunting | sunting sumber]Seperti Merge Sort, Quicksort juga dapat diparalelisasikan dikarenakan sifat pembagi-dan-penakluk alaminya. Operasi Partisi In-Place sulit untuk diparalelisasikan, tetapi setelah dibagi, bagian list yang berbeda dapat diurutkan secara paralel. Berikut ini merupakan pendekatan langsung: Jika kita memiliki prosesor , kita dapat membagi list dari element menjadi sublist pada rata-rata waktu O(n), kemudian mengurutkannya pada rata-rata waktu . Abaikan pra pengolahan O(n) dan waktu penggabungan merupakan Linear Speedup atau Percepatan Linear. Jika pemisahannya tak tampak, abaikan nilai waktu penggabungan O(n). Jika Partisi pemisah didasari pada penggantian pivot, sangat rumit untuk memparelisasikan dan secara langsung memiliki nilai waktu O(n). Jika diberikan O(logn) atau lebih banyak prosesor, hanya sebesar O(n) waktu keseluruhan yang digunakan, sedangkan pendekatan dengan linear speedup akan mencapai waktu O(log n) secara keseluruhan. Salah satu keuntungan dari quicksort paralel sederhana daripada algortima sorting paralel yang lain ialah tidak dibutuhkannya sinkronisasi, tetapi kerugiannya ialah tipe sorting ini masih membutuhkan O(n) dan hanya sublinear speedup dari O(log n) yang dapat dicapai. Rangkaian baru dimulai segera setelah sublist tersedia untuk bekerja dan tidak berkomunikasi dengan rangkaian yang lain. Ketika setelah semua rangkaian selesai, Proses sorting juga akan selesai. Satu lagi algortima sorting paralel yang mutakhir dapat mencapai ikatan waktu yang bahkan lebih baik.[8] Sebagai contoh pada tahun 1991 David Powers menjelaskan quicksort paralelisasi (dan radix sort yang dapat berjalan di waktu O(log n) pada CRWC prosesor n dengan menjalankan pemisahan secara tak langsung.[9] Analisis Average-case menggunakan kemungkinan berlainan[sunting | sunting sumber]Quicksort menggunakan waktu rata-rata O(n log n), ketika inputan merupakan permutasi acak. Mengapa? Sebagai pemulaian, tidak sulit untuk mengetahui bahwa opearasi pemisahan menggunakan O(n) waktu. Pada kasus unbalance sering muncul, setiap kita melakukan partisi kita membagi list menjadi dua buah sublist dari besar 0 dan (sebagai contoh jika seluruh elemen array itu sama). Ini berarti setiap rekursif memanggil proses list dari besar kurang satu dari list sebelumnya. Konsekuensinya, kita dapat membuat penggilan bersarang sebelum kita menccapai list dengan besar 1. Ini berarti bahwa pemanggilan tree ialah rantai linear dari pemanggilan bersarang . Pemanggilan ke- memanggil pada partisi, dan , jadi pada kasus ini, Quick sort mengambil waktu sebesar . Itu merupakan worst case dimana input yang diberikan dari perbandingan dilakukan oleh algoritme sorting, terdapat pula algortima penyesuaian yang secara efektif membuat inputan worst-case pada quicksort menjadi mudah, dengan tanpa teknik pemilihan pivot secara khusus.[10] Pada kasus balance, setiap kali kita melakukan partisi, kita membagi list menjadi dua buah sublist yang bernilai hampir sama. Ini berarti setiap proses pemanggilan rekursif memanggil setengah dari besar list. Konsekuensinya, kita dapat hanya memakai pemanggilan bersarang sebelum mencapai list dengan besar 1. Ini berarti bahwa kedalaman pemanggilan tree sebesar . Tetapi tidak ada dua pemanggilan pada level pemanggilan tree pada bagian yang sama dari list yang aslinya; oleh karena itu setiap level pemanggilan hanya membutuhkan waktu keseluruhan O(n) (setiap pemanggilan memiliki nilai keluar yang konstan, tetapi sejak terdapat hanya O(n) pemanggilan pada setiap level, kejadian ini digolongkan pada faktor O(n)). Hasilnya ialah algortima hanya menggunakan waktu sebanyak O(n log n). Sebenarnya, seimbang secara sempurna tidak dibutuhkan; bahkan jika setiap pivot membagi elemen dengan 75% pada satu sisi dan 25% pada sisi yang lainnya (atau pada pecahan tetap), pemanggilan dalam masih dibutuhkan untuk , jadi total running time masih berupa O(n log n). Jadi apa yang terjadi pada average case? Jika pivot memiliki peringkat acak di tengah 50 persen, yang di antara persentil ke-25 dan persentil ke-75, kemudian memisahkan elemen dengan paling kurang 25% dan paling banyak 75% dari setiap sisi. Jika kita dapat secara konsisten memilih pivot dari pertengahan 50 persen, kita hanya harus memisahkan list paling banyak kali sebelum mencapai list sebesar 1, menghasilkan sebuah algoritme O(n log n) Ketika inputan merupakan permutasi acak, pivot akan memiliki peringkat acak, dan tidak menjamin berada pada pertengahan 50 persen. Bagaimanapun, ketika kita memulai dari permutasi acak, setiap pemanggilan pivot secara rekursif memiliki peringkat acak dari listnya, dan jika terdapat pada pertengahan list, maka akan menghabiskan waktu setengah. Itu cukup bagus, anggap bahwa kamu membalikkan koin: kepala berarti bahwa peringkat pivot berada pada 50 persen, sedang ekor tidak. Anggap bahwa kamu membalikkan coin berkali-kali sehingga mendapatkan kepala sejumlah k, walaupun akan menghabiskan banyak waktu, secara rata-rata hanya membutuhkan pembalikan 2k, kesempatan yang kamu tidak akan dapatkan sebesar kepala setelah lemparan sangat mustahil (dapat diteliti menggunakan ikatan Chernoff). Dengan memakan cara yang sama, rekursif yang dilakukan oleh Quicksort akan mengentikan average case pada pemanggilan dari hanya . Tetapi jika pemanggilan rata-rata ialah O(long n), dan setiap level dari proses pemanggilan tree paling banyak elemen, makan jumlah total dari tugas yang dilakukan pada kasus average case ialah O(n log n). Perlu diperhatikan bahwa algoritme tidak perlu memverifikasi pivot berada ditengah jika diberikan pecahan tetap acak dari berapa kali masukkan, yang cukup untuk kerumitan yang diinginkan. Analisis Average-case menggunakan rekursif[sunting | sunting sumber]Pendekatan alternatif digunakan untuk mengatur hubungan rekursif untuk faktor T(n), waktu yang dibutuhkan untuk mengurutkan list dari besar . Pada sekian banyak kasus unbalanced, satu Quicksort dapat melibatkan tugas O(n) ditambah pemanggilan dua rekursif pada list dan , jadi hubungan rekurensnya ialah Hubungan ini sama dengan Insertion Sort dan Selection Sort, dan dapat menyelesaikan hingga kasus terburuk . Pada kebanyakan kasus balanced, satu pemanggilan quicksort dapat melibatkan O(n) tugas dengan ditambah dua pemanggilan rekursif pada list dengan besar , sehingga hubungan rekursifnya ialah: Teorima dasar menjelaskan kepada kita bahwa T(n) = O(n log n). Garis besar dari pembuktian formal dari O(n log n) dapat dijelaskan sebagai berikut. Asumsikan bahwa tidak ada duplikasi dimana duplikasi itu dapat ditangani dengan pre dan post prosesing linear, atau anggap bahwa kasus lebih mudah dari yang dianalisiskan. Ketika input merupakan permutasi acak, peringkat dari pivot diseragamkan secara acak dari 0 hingga n=1. Kemudian bagian hasil dari partisi memiliki besaran i dan n-i-1, dan i merupakan seragam acak dari 0 hingga n-1. Jadi, jika dirata-ratakan dari semua pemisahan yang mungkin dan melihat bahwa seluruh perbandingan angka untuk pemisahan ialah , jumlah rata-rata dari pembanding dari keseluruhan permutasi dari urutan input dapat diperkirakan secara akuran dengan menyelesaikan hubungan rekursif ini: Dimana rekursifnya Ini berarti bahwa, secara rata-rata, Quicksort melakukan hanya sekitar 39% lebih buruk dari best casenya. Hal ini menjelaskan bahwa average case lebih dekat pada best case daripada worst case. Juga perlu dicatat bahwa Comparison Sort tidak dapat menggunakan kurang dari perbandingan secara rata-rata untuk mengurutkan item. Seandainya besar, maka akan menghasilkan , sehingga quicksort tidak akan lebih buruk dari comparison sort. Perhitungan waktu yang cepat ini menjadi alasan mengapa secara praktiknya quicksort lebih dominan dibandingkan algortima sorting yang lainnya. Analisis Quicksort acak[sunting | sunting sumber]Menggunakan analisis yang sama, seseorang dapat menunjukkan bahwa quicksort yang teracak memiliki sifat yang diinginkan, untuk inputan apapun, membutuhkan O(n log n) kali. Bagaimanapun, terdapat bukti yang kombinatorial, yang lebih elegan dari kedua analisis menggunakan kemungkinan yang berlainan dan analisis menggunakan rekursif. Untuk setiap eksekusi quicksort harus bersesuaian dengan binary search tree (BST): pivot awal berada pada node rootl pivot dari tengah kiri merupakan subtree kiri root, pivot dari tengah kanan merupakan subtree kanan root, dan seterusnya. Jumlah perbandingan dari eksekusi Quicksort sama dengan perbandingan selama konstruksi BST dengan urutan masukan. Jadi, jumlah perbandingan rata-rata untuk Quicksort acak sama dengan average case dari menghasilkan BST ketika nilai yang dimasukkan dari permutasi acak. Ditinjau dari pembuatan BST dengan memasukan urutan nilai yang membentuk permutasi acak. Jika C dianggap sebagai waktu pembuatan BST, maka kita akan memiliki: dengan melinearisasikan ekspektasi, nilai E(C) dari C adalah Tetapkan i dan j<i. Nilai , setelah diurutkan, tetapkan interval j+1. Pengamatan struktural inti dimana dibandingkan dengan pada algoritme jika dan hanya jika jatuh di dalam satu dari dua interval samping pada . Amati bahwa sejak merupakan permutasi acak, juga merupakan permutasi acak, jadi probabilitas berdekatan dengan yang sama persis dengan . Dan menjadi Perhitungan akhir dengan: Kompleksitas Ruang[sunting | sunting sumber]Ruang yang digunakan oleh quicksort tergantung dari versi yang digunakan. Versi In-Place dari Quicksort menggunakan kerumitan ruang dari O(long n), bahkan pada worst case, ketika diimplementasikan menggunakan beberapa strategi berikut:
Quicksort dengan Sistem Partisi In-Place dan unstable menggunakan ruang tambahan konstan sebelum membuat panggilan rekursif manapun. Quicksort haru menyimpan jumlah informasi tetap untuk setiap pemanggilan rekursif bersarang. Sejak best case dapat membuat paling banyak O(long n) pemanggilan rekursif bersarang, yang menggunakan ruang O(log n). Bagaimanapun cara Sedgewick untuk membatasi pemanggilan rekursif, pada worst case quicksort dapat membuat pemanggilan bersarang O(n) dan membutuhkan ruang tambahan O(n). Dari sudut pandang yang lumayan rumit, variabel seperti kiri dan kanan tidak menggunakan ruang konstan; tetapi menggunakan O(log n) bit pada indeks list dari n kali. Karena terdapat variabel pada setiap tumpukan frame, quicksort menggunakan cara Sedgewick yang membutuhkan bit ruang. Kebutuhan ruang ini tidaklah buruk, walaupun sejak jika list yang mengandung elemen berbeda, maka akan membutuhkan paling kurang O(n log n) bits ruang. Lainnya, kurang lebih, yang bukan algoritme In-Place, versi Quicksort yang menggunakan ruang O(n) untuk menyimpan dan dapat mengimplementasikan urutan yang stabil. Tempat penyimpanan menyediakan inputan array dengan mudah dipartisi pada cara yang stabil dan kemudian menyalinnya kembali pada inputan array untuk pemanggilan rekursif yang berurutan. Optimisasi Sedgewick masih sangat sesuai. Pivot yang Berbasis Pemilihan[sunting | sunting sumber]Algoritme seleksi memilih jumlah list k yang terkecil; masalah ini merupakan yang paling mudah secara umumnya daripada sorting. Algoritme seleksi yang sederhana teatpi efektif bekerja hampir sama seperti quicksort, kecuali yang daripada memanggil rekursif pada kedua sublist, algoritme ini hanya membuat satu pemanggilan rekursif ekor pada sublist yang mengandung elemen yang diinginkan. Perubahan kecil ini menurunkan kerumitan rata-rata pada linear atau O(n) kali, dan membuatnya menjadi Algoritme In-Place. Ragam algoritme ini membawa worst case turun menjadi O(n). Sebaliknya setelah kita mengetahui worst case O(n) algoritme seleksi tersedia, kita dapat menggunakannya untuk mencari pivot ideal (median) pada setiap langkah quicksort, yang menghasilkan ragam kalkulasi waktu worst case O(n log n). Pada implementasi praktiknya, bagaimanapun, varian ini dianggap lebih lambat dari rata-rata. Ragam-ragam[sunting | sunting sumber]Terdapat empat ragam quicksort yang paling terkenal:
Membandingkan dengan Algoritme sorting yang lainnya[sunting | sunting sumber]Quicksort ialah versi optimisasi memori dari Binary Tree Sort. Alih-alih memasukkan item secara berurutan pada tree yang jelas, quicksort mengatur mereka secara bersamaan pada tree yang tersirat dengan pemanggilan rekursif. Algoritme membuat perbandingan yang persis sama, tetapi pada urutan yang berbeda. Sifat yang paling diinginkan dari Algoritme Sorting ialah kestabilannya - yang urutan elemennya pada nilai yang sama tidak berubah, memberikan urutan kontrol dari tabel multikey (contoh direktori atau listing folder) pada umumnya. Sifat ini sangat sulit untuk diatur pada quicksort (atau in-place) (yang hanya menggunakan memori tambahan tetap untuk pointer dan buffer, dan memori tambahan lognN untuk pengaturan untuk rekursif yang tampak maupun tidak. Untuk ragam Quicksort melibatkan memori lebih dikarenakan perwakilannya menggunakan pointer (contoh list atau tree) atau file (list yang sering digunakan), yang menjaga stabilitas dengan mudah. Untuk contoh yang lebih kompleks dan rumit, struktur data cenderung meningkatkan waktu yang dibutuhkan, secara umum meningkatkan memori virtual atau disk. Pesaing quicksort langsung ialah Heapsort. Waktu kalkulasi Worst case Heasort selalu bernilai O(n log n). Tetapi average casenya heapsort diasumsikan lebih lambat dari Quicksort in-place standarnya. Masalah ini masih diperdebatkan dan masih diteliti, karena ada beberapa jurnal ilmiah yang mengatakan sebaliknya.[11][12] Introsort merupakan variasi dari quicksort yang menukar heapsort ketika terdapat kasus buruk yang dideteksi untuk menghindari worst case quicksort. Lebih lanjut diketahui heapsort akan sangat dibutuhkan, menggunakan heapsort secara langsung akan lebih cepat daripada harus menunggu introsort untuk menukarnya. Quicksort juga bersaing dengan Mergesort, algoritme sorting rekursif yang lainnya tetapi dengan keuntungan waktu kalkulasi worst casenya O(n log n). Mergesort merupakan sorting stabil, tidak seperti quicksort in-place dan heapsort standar, dan dapat dengan mudah diadaptasikan untuk berjalan pada linked list dan list dengan penyimpanan yang sangat besar pada media dengan akses lambat seperti disk penyimpanan atau penyimpanan pada jaringan. Seperti pula mergesort, quicksort dapat diimplementasikan sebagai sorting stabil in-place,[13] tetapi hal ini jarang digunakan. Walaupun quicksort dikatakan dapat berjalan pada linked list, tapi sering mendapatkan pivot yang buruk tanpa menggunakan akses acak. Kerugian utama dari mergesort ialah, ketika berjalan pada array, implementasi yang efisient membutuhkan ruang tambahan O(n), sedangkan variasi dari quicksort dengan patitisasi in-place dan rekursif ekor hanya menggunakan memori sebesar O(log n). (dengan catatan bahwa ketika menjalankannya pada linked list, mergesort hanya membutuhkan ruang tambahan yang konstan, namun kecil). Bucket Sort dengan dua keranjang atau bucket hampir sama dengan quicksort; pivot pada kasus ini secara efektif mengambil nilai tengah dari range nilai, yang dimana berjalan dengan sangat baik pada average case untuk input yang terdistribusi secara umumnya. Lihat juga[sunting | sunting sumber]Catatan[sunting | sunting sumber]
Referensi[sunting | sunting sumber]
Pranala luar[sunting | sunting sumber]![]()
|