LAPORAN PEMROSESAN DATA

TERDISTRIBUSI

Soal : Quick Sort

Kelompok 3 : 1. (17120104) Angelito Bosco Assuncao Almeida
2. (20120182) Dionisius Duades Nodet
3. (17120096) Matias Mario Naiobe
4. (17120027) Nordes Esa Sanam
5. (19120076) Rizal Saleh Dawa Rae

SEKOLAH TINGGI MANAJEMEN INFORMATIKA KOMPUTER

STIKOM UYELINDO KUPANG
2023
 KATA PENGANTAR

Puji syukur saya panjatkan kehadirat Tuhan YME yang telah memberikan rahmat dan hidayahnya
sehingga kami dapat menyelesaikan makalah ini dengan judul “Quick Sort”. Penyusunan
Makalah ini untuk memenuhi tugas Mata Kuliah Struktur Data dan sebagai bahan untuk mengikuti
Ujian Semester Ganjil Tahun Ajaran 2012 / 2013. Tugas ini dapat terselesaikan karena adanya
dukungan dari berbagai pihak.

Penyusun mengharap kritik yang bersifat membangun dari berbagai pihak demi penyempurnaan
penyusunan karya tuulis pada masa menadatang Harapan penyusun, semoga karya tulis ini dapat
memberikan manfaat bagi penyusun pada khususnya dan pembaca pada umunya yang
berhubungan dengan Quick Sort Materi Struktur Data.

BAB I

PENDAHULUAN

Quicksort diperkenalkan pertama kali oleh C.A.R. Hoare pada tahun 1960, dan dimuat sebagai
artikel di Computer Journal 5 pada April 1962. Bentuknya yang sederhana, efisien dan efektif
dengan cepat membuatnya menjadi algoritma pengurutan (sorting) yang paling banyak digunakan,
terutama dalam bahasa pemrograman. Berbagai penelitian dan pengembangan telah banyak
dilakukan hingga saat ini. Tercatat peneliti seperti Sedgewick, Bentley, McIlroy, Clement, Flajolet,
Vallee, hingga Martinez, membuat analisis dan implementasi dari quicksort.

Beberapa hal yang membuat quicksort unggul:

• Secara umum memiliki kompleksitas O(n log n).

• Algoritmanya sederhana dan mudah diterapkan pada berbagai bahasa pemrograman dan
arsitektur mesin secara efisien.
• Dalam prakteknya adalah yang tercepat dari berbagai algoritma pengurutan dengan
perbandingan, seperti mergesort dan heapsort.
• Melakukan proses langsung pada input (in-place) dengan sedikit tambahan memori.
• Bekerja dengan baik pada berbagai jenis input data (seperti angka dan karakter).
Namun terdapat pula kelemahan quicksort:
• Sedikit kesalahan dalam penulisan program membuatnya bekerja tidak beraturan (hasilnya
tidak benar atau tidak pernah selesai).
• Memiliki ketergantungan terhadap data yang dimasukkan, yang dalam kasus terburuk
memiliki kompleksitas O(n2).
• Secara umum bersifat tidak stable, yaitu mengubah urutan input dalam hasil akhirnya
(dalam hal inputnya bernilai sama).
• Pada penerapan secara rekursif (memanggil dirinya sendiri) bila terjadi kasus terburuk
dapat menghabiskan stack dan memacetkan program.
Pada bahasa pemrograman, quicksort ada dalam pustaka stdlib.h untuk bahasa C, dan class TList
dan TStringList dalam Delphi (Object Pascal) maupun FreePascal.

Algoritma quicksort bekerja menurut prinsip bagi-dan-pecahkan (divide-and-conquer). Dengan

demikian hal mendasar dalam algoritma quicksort adalah pemilihan poros (pivot) dan pembuatan
partisi sedemikian rupa sehingga elemen dengan nilai kecil ada di bagian kiri poros dan elemen
dengan nilai besar ada di bagian kanan poros.

Berbagai varian dari quicksort pada intinya berupaya untuk mengembangkan teknik-teknik
pembuatan partisi yang efektif untuk berbagai macam masukan. Hal ini merupakan bahan yang
terus dipelajari hingga kini. Ditambah pula dengan perbaikan dari segi pemrograman sehingga
lebih efisien (seperti mengurangi operasi pembandingan, pertukaran maupun perulangan).

Pada tahun 1998 M.D. McIlroy membuat tulisan berjudul “A Killer Adversary for Quicksort” yang
menguraikan cara untuk membuat susunan data tertentu (dalam array) hingga operasi pengurutan
menggunakan quicksort mendekati kuadratik O(n2). Cara ini berlaku untuk setiap varian dari
quicksort dengan syarat tertentu. Dikenal juga dengan istilah antiqsort.

Makalah ini akan membahas beberapa varian quicksort yang tersedia luas dan mengujinya
terhadap berbagai susunan data tertentu, termasuk juga antiqsort, untuk memperlihatkan
kompleksitas dari quicksort yang sesungguhnya.

BAB II

PEMBAHASAN

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.
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 Algortima 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

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’

f ‘x’ ≤ ‘pivot’ then append ‘x’ to ‘less’

else append ‘x’ to ‘greater’

return concatenate(quicksort(‘less’), ‘pivot’, quicksort(‘greater’)) // two recursive calls

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

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+1function
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 itemsif ‘left’ < ‘right’// See
“Choice of pivot” section below for possible choiceschoose 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

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.

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
Dua optimisasi penting lainnya, juga disarankan oleh Robert Sedgewick, sebagai pernyataan yang
secara umum diakui, dan digunakan secara luas ialah:

• 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 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. 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.

Analisa Formal

Analisa 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.

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 diantara 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 . 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 algoritma tidak perlu memverifikasi
pivot berada ditengah jika diberikan pecahan tetap acak dari berapa kali masukkan, yang cukup
untuk kerumitan yang diinginkan.

Analisa 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 dianalisakan. 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 dari pada 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.

Analisa Quicksort acak

Menggunakan analisa 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 analisa
menggunakan kemungkinan yang berlainan dan analisa 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 didalam 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 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

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.

Algoritma Quick Sort Menggunakan C/C++

Divide

Memilah rangkaian data menjadi dua sub-rangkaian A[p…q-1] dan A[q+1…r] dimana setiap
elemen A[p…q-1] adalah kurang dari atau sama dengan A[q] dan setiap elemen pada
A[q+1…r] adalah lebih besar atau sama dengan
elemen pada A[q]. A[q] disebut sebagai elemen pivot. Perhitungan pada elemen q
merupakan salah satu bagian dari prosedur pemisahan.

Conquer

Mengurutkan elemen pada sub-rangkaian secara rekursif Pada algoritma quick sort, langkah
”kombinasi” tidak di lakukan karena telah terjadi pengurutan elemen – elemen pada sub array.

Pseudocode Quick Sort

Contoh Quick Sort

Analisis Algoritma QuickSort

Setiap elemen yang akan disort selalu diperlakukan secara sama di sini, diambil salah satu elemen,
dibagi menjadi 3 list, lalu ketiga list tersebut disort dan digabung kembali. Contoh kode di atas
menggunakan
3 buah list, yaitu yang lebih besar, sama dan lebih kecil nilainya dari pivot. Untuk membuat lebih
efisien, bisa digunakan 2 buah list dengan mengeliminasi yang nilainya sama (bisa digabung ke
salah satu dari 2 list yang lain). Kasus terburuk dari algoritma ini adalah saat dibagi menjadi 2
list, satu list hanya terdiri dari 1 elemen dan yang lain terdiri dari n-2 elemen. Untuk kasus terburuk
dan kasus rata-rata, algoritma ini memiliki kompleksitas sebesar O(n log n). Jumlah rata-rata
perbandingan untuk quick sort berdasarkan permutasinya dengan asumsi bahwa nilai pivot diambil
secara random adalah :

Lalu bagaimana cara menentukan pivot sendiri? Kasus terbaik yang diharapkan diilustrasikan
sebagai berikut:
Bagi sebuah list menjadi 4 buah. Lalu pilih 2 buah list sedemikian rupa sehingga setiap elemennya
lebih besar dari 25 % elemen terkecil dan lebih kecil dari 25% elemen terbesar. Bila nilai pivot
yang dipilih secara konstan terambil dari nilai ini maka hanya diperlukan pembagian list sebanyak
2log2n kali.Biladibandingkan dengan merge sort, quick sort memiliki keuntungan di kompleksitas
waktu sebesar Θ(log n), dibanding dengan merge sort sebesar Θ(n). namun quick sort tidak
mampu membandingkan linked list sebaik merge sort, karena ada kemungkinan pemilihan pivot
yang buruk. Selain itu pada linked list merge sort memerlukan ruang yang lebih sedikit.
Berdasarkan analisis tersebut quick sort termasuk algoritma sorting yang cukup baik, namun kita
pun harus bisa memilih nilai pivot yang baik agar penggunaannya bisa optmal.

Implementasi Quic Sort Menggunakan C/C++

Partition(A, p, r)

x = A[p]; //pivot=elemen posisi pertama

i = p ; //inisialisasi

j=r;

repeat

while(A[j] > x)

j–;

while(A[i] < x)

i++;

if (i < j){

Swap(A, i, j);

j–;

i++

else

return j;

until i >= j
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). 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. 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, 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.

BAB III

KESIMPULAN

Quick sort merupakan algoritma yang mempartisi banyaknya data yang dimasukan untuk
mempercepat proses. Dimana inputan yang dimasukan adalah n buah masukan. Algoritma ini
memiliki kompleksitas saat kondisi teburuk (worst case) Tn=O(n2) dan kondisi terbaik (best case)
Tn= O(n 2log n).

Beberapa hal yang membuat quick sort unggul:

• Secara umum memiliki kompleksitas O(n log n).

• Algoritmanya sederhana dan mudah diterapkan pada berbagai bahasa pemrograman dan
arsitektur mesin secara efisien.
• Dalam prakteknya adalah yang tercepat dari berbagai algoritma pengurutan dengan
perbandingan, seperti merge sort dan heap sort.
• Melakukan proses langsung pada input (in-place) dengan sedikit tambahan memori.
• Bekerja dengan baik pada berbagai jenis input data (seperti angka dan karakter).

Namun terdapat pula kelemahan quick sort:

• Sedikit kesalahan dalam penulisan program membuatnya bekerja tidak beraturan (hasilnya
tidak benar atau tidak pernah selesai).
• Memiliki ketergantungan terhadap data yang dimasukkan, yang dalam kasus terburuk
memiliki kompleksitas O(n2).
• Secara umum bersifat tidak stable, yaitu mengubah urutan input dalam hasil akhirnya
(dalam hal inputnya bernilai sama).
• Pada penerapan secara rekursif (memanggil dirinya sendiri) bila terjadi kasus terburuk
dapat menghabiskan stack dan memacetkan program.

BAB IV

DAFTAR PUSTAKA

• http://fairuzelsaid.wordpress.com/2010/01/03/struktur-data-implementasi-quick-sort-
menggunakan-cc/
• http://logicexploration.blogspot.com/2011/05/analisa-algoritma-quick-sort.html
• http://trikswandari.blogspot.com/2009/06/artikel-quick-sort.html
• http://oguds.wordpress.com/2007/11/28/analisis-algoritma-quicksort/