Quicksort

Quicksort merupakan Algoritme pengurutan yang dikembangkan oleh Tony Hoare. performa rata-rata pengurutan O(n log n) untuk mengurutkan n item. Algoritma ini juga dikenal sebagai Partition-Exchange Sort atau disebut sebagai Sorting Pergantian Pembagi. Pada kasus terburuknya, algoritma ini membuat perbandingan O(n2), walaupun kejadian seperti ini sangat langka. Quicksort sering lebih cepat dalam praktiknya daripada algoritma urut gabung dan heapshort.S. S. Skiena, The Algorithm Design Manual, Second Edition, Springer, 2008, p. 129 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).

Quicksort merupakan sorting pembanding dan pada implementasi efisien tidak merupakan algoritma sorting yang stabil.

 Algoritma 
Quicksort merupakan Algoritma 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 
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

ka|200px|jmpl|Contoh keseluruhan dari quicksort pada kumpulan acak dari angka. Element yang gelap merupakan pivot. Pivot selalu dipilih sebagai element terakhir pada partisi. Bagaimanapun, selalu memilih elemen terakhir pada partisi sebagai pivot sehingga hasil pada kasus terburuk () pada daftar yang telah diurutkan, atau daftar yang serupa. Karena elemen yang sama memotong hingga pada akhir dari prosedur soring pada jumlah yang besar, versi dari algoritme quicksort yang memilih pivot sebagai elemen tengah berjalan lebih cepat daripada algortima yang dijelaskan pada diagram ini pada sejumlah besar angka.

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 algoritma 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, algoritma tidak akan mengubah data; untuk jumlah data yang lebih besar, algoritma akan menghasilkan dua bagian, elemen yang kurang dari pivot dan elemen yang lebih besar dari nya, data ini sendiri akan diurutkan secara hipotesis rekursif.

350px|jmpl|kiri|Contoh dari penerapan Quicksort.

200px|jmpl|kiri|Partisi ditepat bekerja pada daftar yang kecil. Elemen kotak merupakan element pivot, elemen berwarna biru merupakan elemen yang bernilai kecil atau sama, dan elemen yang berwarna merah lebih besar.

 Versi In-place 
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 algoritma 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 Algoritma Partisi In-Place. algortima ini memisahkan bagian dari array antara index kiri dan kanan secara inklusif, dengan memindahkan seluruh elemen kurang dari array[pivotIndex] sebelum pivot, dan elemen yang sama atau lebih besar darinya. Dalam prosesnya, algoritma ini juga mencari posisi akhir untuk elemen pivot, yang kembali. algoritma ini secara sementara memindahkan elemen pivot pada akhir dari subarray, sehingga tidak mengganggu proses algoritma. Karena hanya menggunakan penukaran, list akhir memiliki elemen yang sama seperti elemen awalnya. Perlu diperhatikan bahwa elemen ditukan beberapa kali sebelum mencapai tempat akhirnya. Dan juga, jika pivot itu ganda pada inputan array, mereka dapat menyebar pada subarray kanan, pada urutan apapun. Cara ini tidak mewakili kesalahan dalam membagi, dimana pengurutan lebih lanjut akan memindahkan dan akhirnya merekatkan mereka bersama.

Setelah kita memiliki ini, menulis quicksort sendiri ialah mudah:

  function quicksort(array, 'left', 'right')

      // If the list has 2 or more items
      if 'left' < 'right'

          // See "Choice of pivot" section below for possible choices
          choose any 'pivotIndex' such that 'left' ≤ 'pivotIndex' ≤ 'right'

          // Get lists of bigger and smaller items and final position of pivot
          'pivotNewIndex':= partition(array, 'left', 'right', 'pivotIndex')

          // Recursively sort elements smaller than the pivot
          quicksort(array, 'left', 'pivotNewIndex' - 1)

          // Recursively sort elements at least as big as the pivot
          quicksort(array, 'pivotNewIndex' + 1, 'right')

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, algoritma 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 
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.R. Sedgewick, Algorithms in C, Parts 1-4: Fundamentals, Data Structures, Sorting, Searching, 3rd Edition, Addison-WesleyR. Sedgewick, Implementing quicksort programs, Comm. ACM, 21(10):847-857, 1978.

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 
Dua optimisasi penting lainnya, juga disarankan oleh Robert Sedgewick, sebagai pernyataan yang secara umum diakui, dan digunakan secara luas ialah:qsort.c in GNU libc: , http://www.ugrad.cs.ubc.ca/~cs260/chnotes/ch6/Ch6CovCompiled.html
 Untuk meyakinkan paling banyak ruang O(log N) digunakan, pertama sekali algoritma melakukan rekursif pada bagian array yang lebih kecil, dan menggunakan pemanggilan ekor untuk merekursif yang lainnya.
 Menggunakan Insertion Sort, yang memiliki faktor konstant dan lebih cepat pada array yang lebih kecil, untuk pengerjaan pada array yang lebih kecil (dimana panjang nya kurang dari ambang t yang ditentukan secara percobaan). Cara ini dapat diimplementasikan dengan meninggalkan beberapa array tak terurut dan menjalankan Insertion Sort tunggal di akhir, karena tipe sorting ini menangani array yang terurut secara efisien. Insertion Sort yang terpisah pada setiap segmen kecil yang dimana mereka dikenal menambahkan awal dan akhir tambahan pada banyak sorting yang kecil, tetapi juga mencegah pembuangan kunci pembanding pada banyak segment batas, yang kunci ini akan berurut karena Proses kerja quicksort. Cara ini juga meningkatkan penggunaan cahce.

 Paralelisasi 
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.R.Miller, L.Boxer, Algorithms Sequential & Parallel, A Unified Approach, Prentice Hall, NJ, 2006 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.David M. W. Powers, Parallelized Quicksort and Radixsort with Optimal Speedup, Proceedings of International Conference on Parallel Computing Technologies. Novosibirsk. 1991.

 Analisis Average-case menggunakan kemungkinan berlainan 
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 algoritma sorting, terdapat pula algortima penyesuaian yang secara efektif membuat inputan worst-case pada quicksort menjadi mudah, dengan tanpa teknik pemilihan pivot secara khusus.M. D. McIlroy. A Killer Adversary for Quicksort. Software Practice and Experience: vol.29, no.4, 341–344. 1999. At Citeseer

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 . Namun, 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 algoritma 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 . Namun, 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 algoritma 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 
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 
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 algoritma 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 
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:
 Menggunakan Partisi In-place. Partisi yang tak stabil ini memerlukan ruang O(1).
 Setelah melakukan partisi, partisi yang memiliki elemen yang lebih kecil secara rekursif diurutkan terlebih dahulu, yang membutuhkan ruang paling banyak O(log n). Kemudian partisi lainnya diurutkan menggunakan rekursif ekor atau iterasi, yang tidak ditambahkan pada panggilan tumpukan. Ide ini, seperti yang telah diceritakan diatas, dijelaskan oleh Robert Sedgewick, dan menjaga kedalaman tumpukan dengan O(log n).

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 algoritma 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 
Algoritma seleksi memilih jumlah list k yang terkecil; masalah ini merupakan yang paling mudah secara umumnya daripada sorting. Algoritma seleksi yang sederhana teatpi efektif bekerja hampir sama seperti quicksort, kecuali yang daripada memanggil rekursif pada kedua sublist, algoritma 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 Algoritma In-Place. Ragam algoritma ini membawa worst case turun menjadi O(n).

Sebaliknya setelah kita mengetahui worst case O(n) algoritma 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 
Terdapat empat ragam quicksort yang paling terkenal:

 Balanced Quicksort: memilih pivot mungkin untuk mewakili pertengah dari nilai yang akan dipilih, dan kemudian mengikuti algoritma quicksort seperti biasa.
 External Quicksort: sama seperti quicksort yang biasanya kecuali pivot digantikan dengan buffer. Pertama, baca M/2 elemen pertama dan kedua menjadi buffer dan urutkan mereka. Baca elemen selanjutnya dari awal atau akhir untuk menyeimbangkan penulisan. Jika elemen selanjutnya lebih kurang dari buffer terendah, maka tulis elemen itu pada ruang yang tersedia pada awal. Jika lebih besar dari buffer tertinggi, maka tulis elemen itu pada akhir. Atau tidak tulis buffer terbesar atau terkecil, dan tempatkan elemen selanjutnya pada buffer. Tetap tulis elemen maksimum dan minimum untuk menghindari diurutkannya lagi elemen tengah yang telah terurut. Ketika selesai, tulis buffernya. Secara recursif urutkan kembali partisi yang lebih kecil, dan ulangi urutannya pada partisi yang tersisa. Cara ini merupakan tiga cara quicksort yang yang dimana buffer (partisi tengah) mewakili subarray yang telah diurut dari elemen yang kkira-kira sama dengan pivotnya.
 Tiga cara Quicksort radiks (ditemukan oleh Sedgewick dan juga dikenal sebagai Multikey Quicksort): ialah kombinasi dari Radix sort dan Quicksort. Ambil sebuah elemen dari array (pivotnya) dan tempatkan karakter pertama pada string (multikey). Partisikan elemen sisa menjadi tiga set: karakter yang lebih kecil, sama, dan lebih besar dari karakter pivot. Urut secara rekursif partisi "kurang dari" dan "lebih dari" pada karakter yang sama. Urutkan secara rekursif partisi "sama dengan" dengan karakter selanjutnya (tanda). Pertimbangkan dengan mengurut menggunakan bytes atau words dari panjang W bit, best casenya ialah O(KN) dan worst casenya ialah O(2KN) atau paling tidak O(N2) sebagai quicksort standar, dengan diberikan untuk tanda khusus N<2K, dan K adalah konstanta yang tersembunyi pada seluruh algortima sorting pembanding semuanya termasuk quicksort. Ini merupakan salah satu dari tiga cara quicksort yang partisi tengah mewakili urutan subarray elemen (mudah) yang persis sama dengan pivot.

 Membandingkan dengan Algoritma sorting yang lainnya 
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. Algoritma membuat perbandingan yang persis sama, tetapi pada urutan yang berbeda. Sifat yang paling diinginkan dari Algoritma 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). Namun, 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. 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, algoritma 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, 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, tetapi 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 

 Introsort
 Flashsort

 Catatan 

 Referensi 
 R. Sedgewick, Implementing quicksort programs, Comm. ACM, 21(10):847-857, 1978. Implementing Quicksort Programs
 Brian C. Dean, "A Simple Expected Running Time Analysis for Randomized 'Divide and Conquer' Algorithms." Discrete Applied Mathematics 154(1): 1-5. 2006.
 Hoare, C. A. R. "Partition: Algorithm 63," "Quicksort: Algorithm 64," and "Find: Algorithm 65." Comm. ACM 4(7), 321-322, 1961
 Hoare, C. A. R. "Quicksort." Computer Journal 5 (1): 10-15. (1962). (Reprinted in Hoare and Jones: Essays in computing science, 1989.)
 David Musser. Introspective Sorting and Selection Algorithms, Software Practice and Experience vol 27, number 8, pages 983-993, 1997
 Donald Knuth. The Art of Computer Programming, Volume 3: Sorting and Searching, Third Edition. Addison-Wesley, 1997. ISBN 0-201-89685-0. Pages 113–122 of section 5.2.2: Sorting by Exchanging.
 Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. Introduction to Algorithms, Second Edition. MIT Press and McGraw-Hill, 2001. ISBN 0-262-03293-7. Chapter 7: Quicksort, pp. 145–164.
 A. LaMarca and R. E. Ladner. "The Influence of Caches on the Performance of Sorting." Proceedings of the Eighth Annual ACM-SIAM Symposium on Discrete Algorithms, 1997. pp. 370–379.
 Faron Moller. Analysis of Quicksort. CS 332: Designing Algorithms. Department of Computer Science, Swansea University.
 Conrado Martínez and Salvador Roura, Optimal sampling strategies in quicksort and quickselect. SIAM J. Computing 31(3):683-705, 2001.
 Jon L. Bentley and M. Douglas McIlroy, Engineering a Sort Function, Software—Practice and Experience'', Vol. 23(11), 1249–1265, 1993

 Pranala luar 

 Algoritma sorting animasi: Quicksort – Demonstrasi grafis dan diskusi Quicksort
 Animated Sorting Algorithms: Demonstrasi grafis dan diskusi dari partisi 3-cara Quicksort
 Tutorial interaktif untuk Quicksort
 Quicksort applet dengan pemanggilan rekursif "Urutan-Level" untuk membantu meningkatkan analisis algoritma.
 Open Data Structures - Section 11.1.2 - Quicksort
 Quicksort multidimensional pada Java 
 Implementasi Literatur Quicksort pada ragam bahasa  pada Program Literatur
 Java Applet grafis berwarna  yang dapat bereksperimen dengan pernyataan inisial dan menunjukkan statistik

Kategori:Algoritme pengurutan