Quick Sort

Nama "Quick Sort" berasal dari fakta bahwa, quick sort mampu menyortir daftar elemen data secara
signifikan lebih cepat (dua atau tiga kali lebih cepat) daripada algoritma pengurutan umum mana
pun. Ini adalah salah satu algoritma pengurutan yang paling efisien dan didasarkan pada pemisahan
array (partisi) menjadi yang lebih kecil dan swapping (pertukaran) berdasarkan perbandingan
dengan elemen 'pivot' yang dipilih. Oleh karena itu, quick sort juga disebut sebagai "Partition
Exchange" sort. Seperti Merge sort, Quick sort juga termasuk dalam kategori pendekatan divide and
taklukkan dari metodologi pemecahan masalah.

Aplikasi
Quicksort bekerja dengan cara berikut:

Sebelum menyelami algoritma apa pun, sangat penting bagi kita untuk memahami apa aplikasi dunia
nyatanya. Sortir cepat menyediakan pendekatan cepat dan metodis untuk menyortir daftar hal apa
pun. Berikut adalah beberapa aplikasi di mana quick sort digunakan.

• Komputasi komersial: Digunakan di berbagai organisasi pemerintah dan swasta untuk

tujuan menyortir berbagai data seperti menyortir akun/profil berdasarkan nama atau ID
yang diberikan, menyortir transaksi berdasarkan waktu atau lokasi, menyortir file
berdasarkan nama atau tanggal pembuatan, dll.
• Komputasi numerik: Sebagian besar algoritma yang dikembangkan secara efisien
menggunakan antrian prioritas dan pengurutan balik untuk mencapai akurasi dalam semua
perhitungan.
• Pencarian informasi: Algoritme pengurutan membantu pencarian informasi yang lebih baik
dan cara apa yang lebih cepat daripada mencapai pengurutan menggunakan pengurutan
cepat.

Pada dasarnya, quick sort digunakan di mana-mana untuk hasil yang lebih cepat dan dalam kasus di
mana ada batasan ruang.

Penjelasan
Mengambil pandangan analogis dalam perspektif, pertimbangkan situasi di mana seseorang harus
menyortir kertas yang memuat nama siswa, dengan nama dari A-Z. Seseorang mungkin
menggunakan pendekatan sebagai berikut:

1. Pilih nilai pemisahan apa pun, misalnya L. Nilai pemisahan juga dikenal sebagai Pivot.
2. Bagilah tumpukan kertas menjadi dua. A-L dan M-Z. Tidak perlu bahwa tumpukan harus
sama.
3. Ulangi dua langkah di atas dengan tumpukan A-L, bagi menjadi dua bagian yang signifikan.
Dan tumpukan M-Z, terbelah menjadi dua. Proses ini diulang sampai tumpukan cukup kecil
untuk disortir dengan mudah.
4. Pada akhirnya, tumpukan yang lebih kecil dapat ditempatkan satu di atas yang lain untuk
menghasilkan satu set kertas yang disortir dan dipesan sepenuhnya.
5. Pendekatan yang digunakan di sini adalah reduksi pada setiap split untuk mendapatkan
array elemen tunggal.
 6. Pada setiap split, tiang dibagi dan kemudian digunakan pendekatan yang sama untuk tiang
yang lebih kecil dengan menggunakan metode rekursi.

Secara teknis, quick sort mengikuti langkah-langkah di bawah ini:

Langkah 1. Jadikan elemen apa saja sebagai pivot

Langkah 2. Partisi array berdasarkan pivot
Langkah 3. Terapkan pengurutan cepat pada partisi kiri secara rekursif
Langkah 4. Terapkan pengurutan cepat pada partisi kanan secara rekursif

Cara Kerja
Pernyataan masalah

Perhatikan larik berikut: 50, 23, 9, 18, 61, 32. Kita perlu mengurutkan larik ini dengan cara yang
paling efisien tanpa menggunakan tempat tambahan (penyortiran di tempat).

Tahap Awal dan Tahap Akhir

Langkah 1.
• Jadikan elemen apa pun sebagai pivot: Tentukan nilai apa pun untuk menjadi pivot dari
daftar. Untuk kenyamanan kode, kita sering memilih indeks paling kanan sebagai pivot atau
memilih sembarang secara acak dan menukar dengan paling kanan. Misalkan untuk dua nilai
"Rendah" dan "Tinggi" masing-masing sesuai dengan indeks pertama dan indeks terakhir.
 Dalam kasus kami, rendah adalah 0 dan tinggi adalah 5.
 Nilai pada rendah dan tinggi adalah 50 dan 32 dan nilai pada poros adalah 32.
• Mempartisi array berdasarkan pivot: Panggilan untuk mempartisi yang mengatur ulang array
sedemikian rupa sehingga pivot (32) datang ke posisi sebenarnya (dari array yang diurutkan).
Dan di sebelah kiri pivot, array memiliki semua elemen yang lebih kecil darinya, dan di
sebelah kanan lebih besar darinya.
 Dalam fungsi partisi, kita mulai dari elemen pertama dan membandingkannya
dengan pivot. Karena 50 lebih besar dari 32, kami tidak melakukan perubahan apa
pun dan beralih ke elemen 23 berikutnya.
 Bandingkan lagi dengan pivot. Karena 23 kurang dari 32, kami menukar 50 dan 23.
Array menjadi 23, 50, 9, 18, 61, 32
 Kami beralih ke elemen 9 berikutnya yang lagi-lagi kurang dari pivot (32) sehingga
menukarnya dengan 50 menjadikan array kami sebagai 23, 9, 50, 18, 61, 32.
 Demikian pula, untuk elemen berikutnya 18 yang kurang dari 32, array menjadi 23,
9, 18, 50, 61, 32. Sekarang 61 lebih besar dari pivot (32), maka tidak ada perubahan.
 Terakhir, kami menukar pivot kami dengan 50 sehingga mencapai posisi yang benar.

Jadi poros (32) datang pada posisi sebenarnya dan semua elemen di sebelah kirinya lebih kecil, dan
semua elemen di sebelah kanan lebih besar dari dirinya sendiri.

Langkah 2. Array utama setelah langkah pertama menjadi

23, 9, 18, 32, 61, 50

Langkah 3. Sekarang daftar ini dibagi menjadi dua bagian:
1. Sublist sebelum elemen pivot
2. Sublist setelah elemen pivot
Langkah 4. Ulangi langkah-langkah untuk sublist kiri dan kanan secara rekursif. Array terakhir
dengan demikian menjadi:

9, 18, 23, 32, 50, 61

Contoh Program
#include <bits/stdc++.h>
using namespace std;

// Fungsi utilitas untuk menukar dua elemen

void swap(int* a, int* b)
{
int t = *a;
*a = *b;
*b = t;
}

/* Fungsi ini mengambil elemen terakhir sebagai pivot, tempat

elemen pivot pada posisi yang benar dalam diurutkan
array, dan menempatkan semua lebih kecil (lebih kecil dari pivot)
ke kiri pivot dan semua elemen yang lebih besar ke kanan
dari poros */
int partition (int arr[], int low, int high)
{
int pivot = arr[high]; // pivot
int i = (low - 1); // Indeks elemen yang lebih kecil dan menunjukkan posisi
yang tepat dari pivot yang ditemukan

for (int j = low; j <= high - 1; j++)

{
// Jika elemen saat ini lebih kecil dari pivot
if (arr[j] < pivot)
{
i++; // increment indeks elemen yang lebih kecil
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
return (i + 1);
}

/* Fungsi utama yang mengimplementasikan QuickSort

arr[] --> Array yang akan diurutkan,
rendah -> Mulai indeks,
tinggi -> Indeks akhir */
void quickSort(int arr[], int low, int high)
{
if (low < high)
{
/* pi adalah indeks partisi, arr[p] sekarang
di tempat yang tepat */
 int pi = partition(arr, low, high);

// Urutkan elemen secara terpisah sebelum

// partisi dan setelah partisi
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}

/* Berfungsi untuk mencetak array */

void printArray(int arr[], int size)
{
int i;
for (i = 0; i < size; i++)
cout << arr[i] << " ";
cout << endl;
}

// Driver Code
int main()
{
int arr[] = {23, 9, 18, 32, 61, 50};
int n = sizeof(arr) / sizeof(arr[0]);
quickSort(arr, 0, n - 1);
cout << "Array yang diurutkan: \n";
printArray(arr, n);
return 0;
}

Output Program
C:\Users\User\Documents\Coding\CLionProjects\QuickSort\cmake-build-
debug\QuickSort.exe

Array yang diurutkan:

9 18 23 32 50 61

Process finished with exit code 0

Referensi
https://www.geeksforgeeks.org/quick-sort/

https://www.interviewbit.com/tutorial/quicksort-algorithm/