Quicksort

Dari Wikipedia bahasa Indonesia, ensiklopedia bebas
Langsung ke: navigasi, cari
QuickSort
Quicksort merupakan tindakan dalam membuat daftar angka. Garis horisontal merupakan nilai sumbu.
Visualisasi Algoritma Quicksort. Garis horisontal merupakan nilai sumbu.
Quicksort
Kelas Algoritma Sorting
Waktu O(n2)
Kasus rata-rata O(n log n)
Kasus terburuk O(n log n)

Quicksort merupakan Algoritma Sorting yang dikembangkan oleh Tony Hoare yang, secara kasus rata-rata, membuat 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), malaupun kejadian seperti ini sangat langka. Quicksort sering lebih cepat dalam praktiknya dari pada algoritma O(n log n) yang lainnya.[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 algoritma sorting yang stabil.

Algoritma[sunting | sunting sumber]

Quicksort merupakan Algoritma Pembagi. Pertama sekali 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:

  1. Ambil sebuah elemen, yang disebut dengan pivot, pada sebuah daftar.
  2. 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.
  3. 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
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 (O(n^2)) 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 algoritma quicksort yang memilih pivot sebagai elemen tengah berjalan lebih cepat dari pada 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 hipotesa rekursif.

Contoh dari penerapan Quicksort.
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[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 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.

Implementasi Masalah[sunting | sunting sumber]

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 aritmatika 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]

  • 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[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 p, kita dapat membagi list dari element n menjadi sublist p pada rata-rata waktu O(n), kemudian mengurutkannya pada rata-rata waktu \textstyle O\left(\frac{n}{p} \log\frac{n}{p}\right). 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 dari pada 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 Formal[sunting | sunting sumber]

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 n-1 (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 n-1 sebelum kita menccapai list dengan besar 1. Ini berarti bahwa pemanggilan tree ialah rantai linear dari pemanggilan bersarang n-1. Pemanggilan ke-i memanggil O(n-i) pada partisi, dan \textstyle\sum_{i=0}^n (n-i) = O(n^2), jadi pada kasus ini, Quick sort mengambil waktu sebesar O(n^2). 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.[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 \log n / \log 2 sebelum mencapai list dengan besar 1. Ini berarti bahwa kedalaman pemanggilan tree sebesar \log n / \log 2. 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 \log n/ \log (4/3), 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 \log n/ \log (4/3) 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 k kepala setelah 100k 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 2(\log n/ \log (4/3)). Tetapi jika pemanggilan rata-rata ialah O(long n), dan setiap level dari proses pemanggilan tree paling banyak n 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[sunting | sunting sumber]

Pendekatan alternatif digunakan untuk mengatur hubungan rekursif untuk faktor T(n), waktu yang dibutuhkan untuk mengurutkan list dari besar n. Pada sekian banyak kasus unbalanced, satu Quicksort dapat melibatkan tugas O(n) ditambah pemanggilan dua rekursif pada list 0 dan n-1, jadi hubungan rekurensnya ialah

T(n) = O(n) + T(0) + T(n-1) = O(n) + T(n-1).

Hubungan ini sama dengan Insertion Sort dan Selection Sort, dan dapat menyelesaikan hingga kasus terburuk T(n) = O(n^2). Pada kebanyakan kasus balanced, satu pemanggilan quicksort dapat melibatkan O(n) tugas dengan ditambah dua pemanggilan rekursif pada list dengan besar n/2, sehingga hubungan rekursifnya ialah:

T(n) = O(n) + 2T\left(\frac{n}{2}\right).

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 n-1, jumlah rata-rata dari pembanding dari keseluruhan permutasi dari urutan input dapat diperkirakan secara akuran dengan menyelesaikan hubungan rekursif ini:

C(n) = n - 1 + \frac{1}{n} \sum_{i=0}^{n-1} (C(i)+C(n-i-1))

Dimana rekursifnya C(n) = 2n \ln n = 1.39n \log_2 n.

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 dari pada worst case. Juga perlu dicatat bahwa Comparison Sort tidak dapat menggunakan kurang dari perbandingan \log_2(n!) secara rata-rata untuk mengurutkan n item. Seandainya n besar, maka akan menghasilkan \log_2(n!) \approx n (\log_2 n - \log_2 e), 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 (x_1,x_2,...,x_n) dari permutasi acak.

Ditinjau dari pembuatan BST dengan memasukan urutan (x_1,x_2,...,x_n) nilai yang membentuk permutasi acak. Jika C dianggap sebagai waktu pembuatan BST, maka kita akan memiliki: C=\sum_i \sum_{j<i}

dengan melinearisasikan ekspektasi, nilai E(C) dari C adalah E(C)= \sum_i \sum_{j<i}

Tetapkan i dan j<i. Nilai {x_1,x_2,...,x_j}, setelah diurutkan, tetapkan interval j+1. Pengamatan struktural inti dimana x_i dibandingkan dengan x_j pada algoritma jika dan hanya jika x_i jatuh didalam satu dari dua interval samping pada x_j.

Amati bahwa sejak (x_1,x_2,...,x_n) merupakan permutasi acak, (x_1,x_2,...,x_j,x_i) juga merupakan permutasi acak, jadi probabilitas x_i berdekatan dengan x_j yang sama persis dengan 2/(j+1).

Dan menjadi Perhitungan akhir dengan: E(C)=\sum_i \sum_{j<i} 2/(j+1)= O(\sum_i \log i)=O(n \log n).

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:

  • 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).[3][4]

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 O((\log n)^2) 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[sunting | sunting sumber]

Algoritma seleksi memilih jumlah list k yang terkecil; masalah ini merupakan yang paling mudah secara umumnya dari pada sorting. Algoritma seleksi yang sederhana teatpi efektif bekerja hampir sama seperti quicksort, kecuali yang dari pada 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[sunting | sunting sumber]

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[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. 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). 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 dari pada 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,[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]

  1. ^ S. S. Skiena, The Algorithm Design Manual, Second Edition, Springer, 2008, p. 129
  2. ^ "Data structures and algorithm: Quicksort". Auckland University. 
  3. ^ a b R. Sedgewick, Algorithms in C, Parts 1-4: Fundamentals, Data Structures, Sorting, Searching, 3rd Edition, Addison-Wesley
  4. ^ a b R. Sedgewick, Implementing quicksort programs, Comm. ACM, 21(10):847-857, 1978.
  5. ^ qsort.c in GNU libc: [1], [2]
  6. ^ http://home.tiscalinet.ch/t_wolf/tw/ada95/sorting/index.html
  7. ^ http://www.ugrad.cs.ubc.ca/~cs260/chnotes/ch6/Ch6CovCompiled.html
  8. ^ R.Miller, L.Boxer, Algorithms Sequential & Parallel, A Unified Approach, Prentice Hall, NJ, 2006
  9. ^ David M. W. Powers, Parallelized Quicksort and Radixsort with Optimal Speedup, Proceedings of International Conference on Parallel Computing Technologies. Novosibirsk. 1991.
  10. ^ M. D. McIlroy. A Killer Adversary for Quicksort. Software Practice and Experience: vol.29, no.4, 341–344. 1999. At Citeseer
  11. ^ Hsieh, Paul (2004). "Sorting revisited.". www.azillionmonkeys.com. Diakses 26 April 2010. 
  12. ^ MacKay, David (1 December 2005). "Heapsort, Quicksort, and Entropy". users.aims.ac.za/~mackay. Diakses 26 April 2010. 
  13. ^ A Java implementation of in-place stable quicksort

Referensi[sunting | sunting sumber]

  • 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[sunting | sunting sumber]

Templat:Sorting