Masalah dan Algoritma Pengurutan

1. Introduction

Pengurutan adalah masalah klasik tentang mengubah urutan elemen-elemen (yang bisa dibandingkan, seperti bilangan bulat, bilangan pecahan, strings, dsb) dari sebuah larik (senarai) ke urutan tertentu (menaik, tidak-menurun (menaik atau datar), menurun, tidak-menaik (menurun atau datar), terurut secara abjad, dsb).


Ada banyak algoritma-algoritma pengurutan, dan masing-masing memiliki kekuatan-kekuatan maupun kekurangan-kekurangan.


Pengurutan biasanya digunakan sebagai masalah pembuka dalam berbagai kelas-kelas Ilmu Komputer untuk menjelaskan berbagai ide-ide algoritma.


Tanpa kehilangan makna umum, kami menggunakan asumsi bahwa kita akan mengurutkan hanya bilangan-bilangan bulat, tidak harus unik, ke dalam urutan tidak-menurun di visualisasi ini. Cobalah klik Bubble Sort untuk animasi contoh pengurutan daftar 5 bilangan-bilangan bulat yang tidak beratur (dengan duplikat) diatas.

1-1. Motivasi - Ide-Ide Menarik Info Komputer

Sorting problem has a variety of interesting algorithmic solutions that embody many Computer Science ideas:

  1. Comparison versus non-comparison based strategies,
  2. Iterative versus Recursive implementation,
  3. Divide-and-Conquer paradigm (e.g., Merge Sort or Quick Sort),
  4. Best/Worst/Average-case Time Complexity analysis,
  5. Randomized Algorithms, etc.

1-2. Motivasi - Aplikasi-Aplikasi

Ketika sebuah larik (bilangan bulat) A terurut, banyak masalah-masalah yang berhubungan dengan A menjadi mudah (atau lebih mudah):

  1. Mencari nilai spesifik v di dalam larik A,
  2. Mencari nilai terkecil/terbesar atau nilai terkecil/terbesar ke-k di larik (statis) A,
  3. Mengetes keunikan dan menghapus duplikat dari larik A,
  4. Menghitung seberapa banyak nilai spesifik v muncul dalam larik A,
  5. Himpunan Irisan/Gabungan dari larik A dan larik terurut lainnya yaitu B,
  6. Mencari pasangan target xA dan yA sehingga x+y sama dengan nilai target z,
  7. Menghitung banyak nilai di larik A yang berada pada jangkauan [lo..hi], dsb.

Diskusi: Dalam kelas-kelas nyata, instruktor bisa membahas aplikasi-aplikasi ini dengan lebih detail.

1-3. Beberapa Petunjuk-Petunjuk

[This is a hidden slide]

2. Aksi-Aksi

Ada dua aksi yang anda dapat lakukan di visualisasi ini.

2-1. Masukkan Input Anda Sendiri

Aksi pertama adalah tentang mendefinisikan masukan anda sendiri, sebuah larik/daftar A yang:

  1. Betul-betul acak,
  2. Acak tapi terurut (dalam urutan tidak-menurun atau tidak-menaik),
  3. Acak tetapi hampir terurut (dalam urutan tidak-menurun atau tidak-menaik),
  4. Acak dan memiliki banyak duplikat-duplikat (sehingga jangkauan bilangan-bilangan bulatnya kecil), atau
  5. Didefinisikan oleh anda sendiri.

Dalam mode Eksplorasi, anda dapat bereksperimen dengan berbagai algoritma-algoritma pengurutan yang tersedia di visualisasi ini untuk mengetahui masukan-masukan terbaik dan terjelek untuk algoritma-algoritma tersebut.

2-2. Jalankan Algoritma Pengurutan Terpilih

Aksi kedua adalah yang terpenting: Jalankan algoritma pengurutan yang sedang aktif dengan meng-klik tombol "Urutkan".


Ingat bahwa anda dapat mengubah algoritma yang aktif dengan meng-klik singkatan di sisi atas dari halaman visualisasi ini.

3. Visualisasi

Lihat visualisasi/animasi dari algoritma pengurutan terpilih disini.


Tanpa kehilangan makna umum, kami hanya menunjukkan bilangan-bilangan bulat didalam visualisasi ini dan tujuan kami adalah untuk mengurutkan mereka dari status awal ke status terurut tidak-menurun. Ingat, tidak-menurun berarti pada umumnya urutan menaik (atau membesar), tetapi karena bisa ada duplikat-duplikat, bisa ada garis datar/sama diantara dua bilangan-bilangan bulat bersisian yang bernilai sama.

4. Algoritma-Algoritma Pengurutan Umum

Di bagian atas halaman ini, anda akan melihat daftar berbagai algoritma-algoritma pengurutan yang biasanya diajarkan dalam kelas-kelas Ilmu Komputer. Untuk mengaktifkan algoritma tertentu, pilihlah singkatan dari nama algoritma yang bersangkutan sebelum meng-klik "Urutkan".


Untuk memfasilitasi keberagaman, kami akan mengacak algoritma yang aktif setiap kali halaman ini ditampilkan.


Enam algoritma pertama adalah berbasis-pembandingan sedangkan dua terakhir tidak. Kita akan membahas ide ini di pertengahan Kuliah Maya ini.


Tiga algoritma ditengah adalah algoritma pengurutan yang bersifat rekursif sedangkan sisanya biasa diimplementasikan secara iteratif.

4-1. Singkatan-Singkatan

Supaya muat di layar, kami menyingkat nama-nama algoritma menjadi tiga karakter saja:

  1. Algoritma-Algorithma Pengurutan berbasis-pembandingan:
    1. BUB - Bubble Sort,
    2. SEL - Selection Sort,
    3. INS - Insertion Sort,
    4. MER - Merge Sort (implementasi rekursif),
    5. QUI - Quick Sort (implementasi rekursif),
    6. R-Q - Quick Sort Acak (implementasi rekursif).
  2. Algoritma-Algoritma Pengurutan tidak berbasis-pembandingan:
    1. COU - Counting Sort,
    2. RAD - Radix Sort.

5. 3 O(N^2) Algoritma Berbasis-Pembandingan

Kita akan membahas tiga algoritma-algoritma pengurutan berbasis-pembandingan di beberapa slides berikutnya:

  1. Bubble Sort,
  2. Selection Sort,
  3. Insertion Sort.

Mereka disebut berbasis-pembandingan karena mereka membandingkan pasangan elemen-elemen dari sebuah larik dan menentukan apakah akan menukar posisi mereka atau tidak.


Ketiga algoritma-algoritma pengurutan ini adalah yang termudah untuk diimplementasikan tetapi juga bukan yang paling efisien, karena mereka berjalan dalam kompleksitas waktu O(N2).

6. (Dasar) Analisa Algoritma-Algoritma

Sebelum kita memulai diskusi berbagai algoritma-algoritma pengurutan, adalah ide bagus untuk membahas dasar-dasar dari analisa algoritma secara asimptotik, sehingga anda dapat mengikuti diskusi-diskusi dari berbagai algoritma-algoritma pengurutan O(N^2), O(N log N), dan spesial O(N) nantinya.


Section ini bisa dilompati jika anda sudah mengetahui topik ini.

6-1. Prasyarat Matematik

Anda butuh untuk sudah mengerti/mengingat hal-hal ini:
-. Logaritma dan Eksponen, misalkan log2(1024) = 10, 210 = 1024
-. Deret Aritmetika, misalkan 1+2+3+4+…+10 = 10*11/2 = 55
-. Deret Geometri, misalkan 1+2+4+8+..+1024 = 1*(1-211)/(1-2) = 2047
-. Fungsi Linear/Kuadratik/Kubik, misalkan f1(x) = x+2, f2(x) = x2+x-1, f3(x) = x3+2x2-x+7
-. Fungsi Langit-Langit, Lantai, dan Absolut, misalkan ceil(3.1) = 4, floor(3.1) = 3, abs(-7) = 7

6-2. Apa Itu?

Analisis algoritma adalah sebuah proses untuk mengevaluasi secara keras sumber daya (waktu dan ruang) yang dibutuhkan oleh sebuah algoritma dan merepresentasikan hasil dari evaluasi tersebut dengan sebuah formula (sederhana).


Kebutuhan waktu/ruang dari sebuah algoritma juga disebut sebagai kompleksitas waktu/ruang dari algoritma tersebut, masing-masing.


Untuk modul ini, kita lebih memfokuskan kepada persyaratan waktu dari berbagai algoritma-algoritma pengurutan.

6-3. Mengukur Waktu Runtime Sesungguhnya?

Kita bisa mengukur waktu perjalanan aktual dari sebuah program dengan menggunakan waktu jam dinding atau dengan memasukkan kode pengukuran-waktu kedalam program kita, misalkan lihat kode yang ditunjukkan didalam SpeedTest.cpp | py | java.


Tetapi, waktu perjalanan aktual tidak berarti banyak ketika membandingan dua algoritma-algoritma karena mereka mungkin ditulis dalam bahasa-bahasa yang berbeda, menggunakan set-set data yang berbeda, atau berjalan pada komputer-komputer yang berbeda.

6-4. Menghitung # Operasi (1)

Daripada mengukur waktu sebenarnya, kita bisa menghitung # dari operasi-operasi (aritmetik, penugasan, pembandingan, dsb). Ini adalah cara untuk mengukur efesiensi karena waktu eksekusi dari sebuah algoritma terkorelasi dengan # operasi-operasi yang dibutuhkannya.


Lihat kode yang ditunjukkan di SpeedTest.cpp | py | java dan komentar-komentarnya (terutama tentang bagaimana mendapatkan nilai final dari variabel counter).


Mengetahu jumlah operasi-operasi (persis) yang dibutuhkan oleh sebuah algoritma, kita bisa menyatakan sesuatu seperti ini: Algoritma X membutuhkan 2n2 + 100n operasi-operasi untuk menyelesaikan masalah dengan ukuran n.

6-5. Menghitung # Operasi (2)

Jika waktu t yang dibutuhkan untuk sebuah operasi diketahu, maka kita bisa menyatakan bahwa algoritma X membutuhkan (2n2 + 100n)t unit-unit waktu untuk menyelesaikan masalah dengan ukuran n.


Tetapi, waktu t tergantung dari faktor-faktor yang disebut sebelumnya, misalkan bahasa-bahasa, kompiler-kompiler, dan komputer-komputer yang berbeda, dsb.


Oleh karena itu, daripada menghubungkan analisa ke waktu t yang sebenarnya, kita bisa menyatakan bahwa algoritma X membutuhkan waktu yang proporsional terhadap 2n2 + 100n untuk menyelesaikan masalah dengan ukuran n.

6-6. Analisa Asymptotic

Analisa Asimtotik adalah sebuah analisa algoritma-algoritma yang berfokus pada penganalisaan masalah-masalah dengan ukuran masukan n yang besar, memikirkan hanya term tertinggi saja dari formula, dan mengabaikan koefisien dari term tertinggi.


Kita memilih term tertinggi karena term-term yang lebih kecil berkontribusi lebih sedikit kepada biaya total saat ukuran masukan bertumbuh besar, misalkan untuk f(n) = 2n2 + 100n, kita punya:
f(1000) = 2*10002 + 100*1000 = 2.1M, versus
f(100000) = 2*1000002 + 100*100000 = 20010M.
(sadari bahwa term yang lebih kecil 100n memiliki kontribusi yang lebih kecil).

6-7. Mengabaikan Koefisien dari Term Paling Depan

Misalkan dua algoritma-algoritma memiliki 2n2 dan 30n2 sebagai term-term tertinggi.


Meskipun waktu sebenarnya akan berbeda karena konstanta-konstanta yang berbeda, laju-laju pertumbuhan dari waktu eksekusi adalah sama.


Dibandingkan dengan algoritma lain dengan term tertinggi n3, perbedaan dari laju pertumbuhan adalah faktor yang jauh lebih dominan.


Maka, kita bisa melepaskan koefisien dari term tertinggi ketika mempelajari kompleksitas algoritma.

6-8. Batas Atas: Notasi Big-O

Jika algoritma A membutuhkan waktu proporsional terhadap f(n), kita bilang bahwa algoritma A berada dalam order f(n).


Kita menulis bahwa algoritma A mempunyai kompleksitas waktu O(f(n)), dimana f(n) adalah fungsi laju pertumbuhan untuk algoritma A.

6-9. Notasi Big-O (Matematik)

Secara matematis, sebuah algoritma adalah O(f(n)) jika ada sebuah konstanta k dan sebuah bilangan bulat positif n0 sehingga algoritma A membutuhkan tidak lebih dari k*f(n) unit-unit waktu untuk menyelesaikan sebuah masalah dengan ukuran n ≥ n0, yaitu, jika ukuran masalah lebih besari dari n0, algoritma A (selalu) dibatasi dari atas oleh formula sederhana k*f(n) ini.


Big-O Notation

Catat bahwa: n0 dan k tidak unik dan bisa ada beberapa banyak f(n) valid yang memungkinkan.

6-10. Term-Term Pertumbuhan

Dalam analisa asimtotik, sebuah formula bisa disederhanakan menjadi sebuah term tunggal dengan koefisien 1.


Term tersebut disebut sebagai term pertumbuhan (tingkat pertumbuhan, urutan pertumbuhan, urutan besar).


Term-term pertumbuhan yang paling umum dapat diurutkan dari yang paling cepat ke paling lambat sebagai berikut:
O(1)/waktu konstan < O(log n)/waktu logaritmik < O(n)/waktu linear <
O(n log n)/waktu kuasilinear < O(n2)/waktu kuadratik < O(n3)/waktu kubik <
O(2n)/waktu eksponensial < O(n!)/waktu juga-eksponensial < ∞ (misalkan, perulangan tak berakhir).


Catat bahwa ada beberapa kompleksitas-kompleksitas waktu yang umum lainnya yang tidak ditunjukkan (lihat juga visualisasi di slide berikutnya)).

6-11. Term-Term Pertumbuhan (Divisualisasikan/Dibandingkan)

Common Growth Terms

Kita akan melihat tiga laju-laju pertumbuhan yang berbeda O(n2), O(n log n), dan O(n) sepanjang sisa dari modul pengurutan ini.

7. Bubble Sort

Diberikan sebuah larik berisi N elemen-elemen, Bubble Sort akan:
  1. Membandingkan pasangan yang bersebelahan (a, b),
  2. Menukar pasangan tersebut bila tidak pada urutan yang seharusnya (dalam kasus ini, ketika a > b),
  3. Ulangi Langkah 1 dan 2 hingga kita sampai di akhir larik
    (pasangan terakhir adalah elemen ke (N-2) dan (N-1) karena kita menggunakan indeks basis-0),
  4. Pada saat ini, elemen terbesar akan terletak pada posisi terakhir.
    Kita lalu mengurangi N dengan 1 dan kembali ke Langkah 1 sampai kita mendapat N = 1.

Tanpa basa-basi lagi, mari coba Bubble Sort pada larik contoh kecil [29, 10, 14, 37, 14].


Anda akan melihat animasi 'seperti-gelembung' jika anda membayangkan elemen-elemen yang besar 'menggelembung keatas' (atau sebenarnya 'bergerak ke sisi kanan dari larik').

7-1. Bubble Sort: Kode C++ dan Analisa

void bubbleSort(int a[], int N) { // versi standar
for (; N > 0; --N) // N iterasi-iterasi
for (int i = 0; i < N-1; ++i) // kecuali terakhir, O(N)
if (a[i] > a[i+1]) // tidak dalam urutan tidak-menurun
swap(a[i], a[i+1]); // tukar dalam O(1)
}

Pembandingan dan penukaran membutuhkan waktu yang dibatasi oleh sebuah konstanta, mari sebut saja dengan c. Lalu, ada dua perulangan (loop) yang bertingkat (nested) dalam Bubble Sort standar. Perulangan (loop) luar berjalan tepat sebanyak N iterasi. Tetapi pengulangan (loop) dalam menjadi sedikit lebih pendek pada setiap iterasi:

  1. Saat i=0, (N−1) iterasi (dari pembandingan-pembandingan dan kemungkinan pertukaran-pertukaran),
  2. Saat i=1, (N−2) iterasi,
    ...,
  3. Saat i=(N−2), 1 iterasi,
  4. Saat i=(N−1), 0 iterasi.

Sehingga, jumlah total dari iterasi = (N−1)+(N−2)+...+1+0 = N*(N−1)/2 (penurunan)
Waktu total adalah = c*N*(N−1)/2 = O(N^2)

7-2. Bubble Sort: Diberhentikan Lebih Awal

Bubble Sort sebenarnya tidak efisien dengan kompleksitas waktu O(N^2). Bayangkan jika kita memiliki N = 105 angka-angka. Meskipun komputer kita sangat cepat dan dapat menghitung 108 operasi-operasi dalam 1 detik, Bubble Sort akan membutuhkan sekitar 100 detik untuk menyelesaikan tugas ini.


Tetapi, Bubble Sort dapat dihentikan lebih awal, misalkan pada contoh kecil yang telah terurut menaik diatas [3, 6, 11, 25, 39], Bubble Sort dapat dihentikan dalam waktu O(N).


Idenya mudah: Jika kita melalui perulangan dalam (inner loop) tanpa melakukan pertukaran sama sekali, itu berarti bahwa larik tersebut sudah terurut dan kita dapat menghentikan Bubble Sort pada saat itu.


Diskusi: Meskipun ide tersebut membuat Bubble Sort berjalan lebih cepat dalam kasus-kasus umum, ide ini tidak mengubah kompleksitas waktu O(N^2) dari Bubble Sort... Kenapa?

7-3. Jawaban

[This is a hidden slide]

8. Selection Sort

Diberikan sebuah larik berisi N elemen dan L = 0, Selection Sort akan:

  1. Menemukan posisi X dari elemen terkecil dalam interval [L...N-1],
  2. Tukar item ke-X dengan item ke-L,
  3. Naikkan batas bawah L sebesar 1 dan kembail ke Langkah 1 sampai L = N-2.

Mari coba Selection Sort pada larik contoh kecil yang sama [29, 10, 14, 37, 13].


Tanpa kehilangan makna umum, kita juga dapat mengimplementasikan Selection Sort secara terbalik:
Temukan posisi dari elemen terbesar Y dan tukar dengan elemen terakhir.

8-1. Selection Sort, Kode C++ & Analisa

void selectionSort(int a[], int N) {
for (int L = 0; L <= N-2; ++L) { // O(N)
int X = min_element(a+L, a+N) - a; // O(N)
swap(a[X], a[L]); // O(1), X may be equal to L (no actual swap)
}
}

Total: O(N2) — To be precise, it is similar to Bubble Sort analysis.

8-2. Kuis

Quiz: How many (real) swaps are required to sort [29, 10, 14, 37, 13] by Selection Sort?

2
1
4
3

9. Insertion Sort

Insertion Sort mirip dengan bagaimana kebanyakan orang menyusun kartu poker di tangan. Tangan poker

  1. Mulai dengan satu kartu di tangan,
  2. Pilih kartu berikutnya dan masukkan ke dalam posisi yang benar,
  3. Ulang langkah tersebut untuk seluruh kartu.

Tanpa basa-basi lagi, mari coba Insertion Sort pada larik contoh kecil [40, 13, 20, 8].

9-1. Insertion Sort, Kode C++ dan Analisa 1

void insertionSort(int a[], int N) {
for (int i = 1; i < N; ++i) { // O(N)
int X = a[i]; // X adalah elemen untuk dimasukkan
int j = i-1;
for (; j >= 0 && a[j] > X; --j) // bisa cepat atau lambat
a[j+1] = a[j]; // buat tempat untuk X
a[j+1] = X; // indeks j+1 adalah titik pemasukkan
}
}

9-2. Insertion Sort: Analisa 2

Perulangan luar (outer loop) dijalankan N−1 kali, sepertinya ini cukup jelas.

Tetapi berapa kali perulangan dalam (inner loop) dilakukan tergantung pada masukan:

  1. Dalam kasus terbaik, larik sudah terurut menaik dan (a[j] > X) selalu salah
    Sehingga tidak ada pergeseran data yang terjadi dan perulangan dalam (inner loop) berjalan dalam O(1),
  2. Dalam kasus terjelek, larik terurut terbalik (menurun) dan (a[j] > X) selalu benar
    Pemasukkan (insertion) selalu terjadi di depan larik dan perulangan dalam (inner loop) berjalan dalam O(N).

Sehingga, waktu terbaik adalah O(N × 1) = O(N) dan waktu terburuk adalah O(N × N) = O(N2).

9-3. Kuis Mini

Quiz: What is the complexity of Insertion Sort on any input array?

O(N)
O(N log N)
O(1)
O(N^2)


Tanya instruktor anda bila anda tidak mengerti tentang hal ini atau baca catatan yang sejenis di slide ini.

10. 2.5 O(N log N) Pengurutan Pembandingan

Kita akan membahas dua (dan setengah) algoritma-algoritma berbasis-pembandingan segera:

  1. Merge Sort,
  2. Quick Sort dan versi acaknya (yang hanya memiliki satu perubahan).

Algoritma-algoritma pengurutan ini biasanya diimplementasikan secara rekursif, menggunakan paradigma pemecahan masalah Divide and Conquer, dan berjalan dalam waktu O(N log N) untuk Merge Sort dan O(N log N) secara ekspektasi untuk Quick Sort Acak.


PS: Versi tidak-acak dari Quick Sort sayangnya berjalan dalam waktu O(N2).

11. Merge Sort

Diberikan sebuah larik berisi N elemen, Merge Sort akan:

  1. Menggabungkan tiap pasang elemen (yang secara default terurut) menjadi larik-larik berukuran 2 elemen,
  2. Menggabungkan tiap pasang larik-larik tersebut menjadi larik-larik berukuran 4 elemen, Ulangi proses ini...,
  3. Langkah terakhir: Menggabungkan 2 larik-larik yang sudah terurut dengan jumlah N/2 elemen (untuk memudahkan diskusi, kita berasumsi bahwa N genap) untuk mendapatkan larik yang terurut penuh dengan jumlah N elemen.

Ini hanyalah ide general dan kita membutuhkan beberapa detail tambahan sebelum kita bisa membahas bentuk sebenarnya dari Merge Sort.

11-1. Sub-rutin Penting, O(N) Merge

Kita akan membahas dengan detil algoritma Merge Sort ini dengan pertama-tama membahas sub-rutin terpentingnya: Proses penggabungan (merge) dalam O(N).


Diberikan dua larik yang sudah terurut, A dan B, dengan ukuran N1 dan N2, kita dapat dengan efisien menggabungkan mereka mejadi satu larik terurut yang lebih besar dengan ukuran N = N1+N2, dalam waktu O(N).


Ini dapat diraih dengan cara membandingkan elemen terdepan dari kedua larik dan mengambil yang terkecil dari dua itu setiap waktu. Tetapi, sub-rutin merge yang sederhana tapi cepat O(N) ini akan membutuhkan larik tambahan untuk melakukan proses penggabungan ini dengan benar.

11-2. Implementasi C++ dari Sub-rutin Merge

void merge(int a[], int low, int mid, int high) {
// subarray1 = a[low..mid], subarray2 = a[mid+1..high], terurut
int N = high-low+1;
int b[N]; // diskusi: kenapa kita butuh larik sementara b?
int left = low, right = mid+1, bIdx = 0;
while (left <= mid && right <= high) // proses penggabungan
b[bIdx++] = (a[left] <= a[right]) ? a[left++] : a[right++];
while (left <= mid) b[bIdx++] = a[left++]; // sisanya, jika ada
while (right <= high) b[bIdx++] = a[right++]; // sisanya, jika ada
for (int k = 0; k < N; ++k) a[low+k] = b[k]; // kopi kembali
}

Cobalah Merge Sort pada larik contoh [1, 5, 19, 20, 2, 11, 15, 17] yang sebagian pertamanya telah terurut [1, 5, 19, 20] dan sebagian keduanya juga telah terurut [2, 11, 15, 17]. Fokus kepada penggabungan terakhir dari algoritma Merge Sort.

11-3. Paradigma Divide and Conquer

Sebelum kita lanjutkan, mari berbicara tentang Divide and Conquer (disingkat sebagai D&C), sebuah paradigma pemecahan masalah yang kuat.


Algoritma Divide and Conquer menyelesaikan (sejenis) masalah — seperti masalah pengurutan kita — dalam beberapa langkah-langkah berikut:

  1. Langkah Divide: Membagi masalah yang asli dan besar menjadi masalah-masalah yang lebih kecil dan secara rekursif menyelesaikan masalah-masalah yang lebih kecil tersebut,
  2. Langkah Conquer: Gabungkan hasil-hasil dari masalah-masalah yang lebih kecil tersebut untuk menghasilkan hasil dari masalah yang asli dan besar.

11-4. Merge Sort Sebagai Algoritma D&C

Merge Sort adalah algoritma pengurutan bersifat Divide and Conquer.


Langkah pembagian (divide) mudah saja: Bagi larik yang sekarang menjadi dua bagian (sama besar jika N genap atau satu sisi satu elemen sedikit lebih besar jika N ganjil) dan lalu secara rekursif mengurutkan kedua bagian tersebut.


Langkah penaklukkan (conquer) adalah langkah yang melakukan usaha terbesar: Gabungkan dua bagian (yang sudah terurut) untuk membentuk larik yang terurut, menggunakan sub-rutin penggabungan (merge) yang dibahas sebelumnya.

11-5. Implementasi C++ dari Merge Sort

void mergeSort(int a[], int low, int high) {
// larik yang akan diurutkan adalah a[low..high]
if (low < high) { // kasus dasar: low >= high (0 or 1 item)
int mid = (low+high) / 2;
mergeSort(a, low , mid ); // bagi jadi dua bagian
mergeSort(a, mid+1, high); // lalu urutkan secara rekursif
merge(a, low, mid, high); // kuasai: sub-rutin merge
}
}

11-6. Demonstrasi

Dibandingkan dengan apa yang biasanya ditampilkan di banyak buku-buku teks Ilmu Komputer yang dicetak (karena buku-buku sifatnya statis), eksekusi sebenarnya dari Merge Sort tidak membagi kedua sub-larik level demi level, tetapi Merge Sort akan secara rekursif mengurutkan sub-larik kiri terlebih dahulu sebelum mengurutkan sub-larik kanan.


Lebih detailnya, menjalankan Merge Sort pada larik contoh [7, 2, 6, 3, 8, 4, 5], Merge Sort akan merekursi ke [7, 2, 6, 3], lalu [7, 2], lalu [7] (sebuah elemen tunggal, yang sudah terurut secara default), kembali, rekursi ke [2] (terurut), kembali, lalu menggabungkan [7, 2] menjadi [2, 7], sebelum Merge Sort memproses [6, 3] dan selanjutnya.

11-7. Merge Sort: Analisa Bagian 1

Dalam Merge Sort, usaha terbanyak dilakukan dalam langkah conquer/merge karena langkah divide sebenarnya tidak melakukan apa-apa (dianggap O(1)).


Ketika kita memanggil merge(a, low, mid, high), kita memproses k = (high-low+1) elemen.
Akan ada paling banyak k-1 pembandingan.
Ada k perpindahan dari larik asli a ke larik temporer b dan k perpindahan lainnya untuk menyalin balik.
Secara total, jumlah operasi dalam operasi sub-rutin merge adalah < 3k-1 = O(k).


Pertanyaan penting berikutnya adalah berapa kali sub-rutin merge ini dipanggil?

11-8. Merge Sort: Analisa Bagian 2

The Recursion Tree of Merge Sort

11-9. Merge Sort: Analisa Bagian 3

Level 1: 2^0=1 panggilan kepada merge() dengan N/2^1 elemen masing-masing, O(2^0 x 2 x N/2^1) = O(N)
Level 2: 2^1=2 panggilan kepada merge() dengan N/2^2 elemen masing-masing, O(2^1 x 2 x N/2^2) = O(N)
Level 3: 2^2=4 panggilan kepada merge() dengan N/2^3 elemen masing-masing, O(2^2 x 2 x N/2^3) = O(N)
...
Level (log N): 2^(log N-1) (atau N/2) panggilan kepada merge() dengan N/2^log N (or 1) elemen masing-masing, O(N)


Ada log N level dan di setiap level, kita melakukan usaha sebesar O(N), sehingga kompleksitas waktu seluruhnya adalah O(N log N). Nanti, kita akan melihat bahwa ini adalah algoritma pengurutan (berbasis-pembandingan) yang sudah optimal, atau dengan kata lain, kita tidak bisa membuat algoritma lebih baik dari Merge Sort ini.

11-10. Bagus dan Jeleknya

Bagian bagus dari Merge Sort yang paling penting adalah garansi performa O(N log N), tidak tergantung pada urutan asli dari masukan. Dengan kata lain, tidak ada kasus tes yang bisa membuat Merge Sort berjalan lebih lambat dari O(N log N) untuk segala larik dengan N elemen.


Merge Sort sangat cocok untuk mengurutkan masukan yang sangat besar karena O(N log N) bertumbuh jauh lebih lambat dari algoritma-algoritma pengurutan yang membutuhkan waktu O(N2) seperti yang dibahas sebelumnya.


Tetapi ada juga beberapa bagian yang tidak bagus dari Merge Sort. Pertama, sebenarnya tidak mudah untuk mengimplementasikan Merge Sort dari awal (tetapi sebenarnya kita tidak perlu melakukannya). Kedua, Merge Sort membutuhkan tempat tambahan sebesar O(N) dalam proses penggabungan, sehingga tidak efisien secara memori dan tidak di-tempat. Ngomong-ngomong, bila anda tertarik untuk melihat apa yang sudah dilakukan untuk mengatasi bagian yang tidak bagus dari Merge Sort (klasik) ini, anda bisa membaca ini


Merge Sort juga adalah algoritma pengurutan yang stabil. Diskusi: Kenapa?

11-11. Jawabannya

[This is a hidden slide]

12. Quick Sort

Quick Sort adalah algoritma pengurutan lain yang juga berbasis Divide and Conquer (satu lagi yang telah dibahas di Kuliah Maya ini adalah Merge Sort).


Kita akan melihat bahwa versi deterministik, tidak acak dari Quick Sort bisa memiliki kompleksitas waktu yang jelek, yaitu O(N2) pada masukan jahat (adversary) sebelum kita melanjutkan pembahasan dengan versi acak yang lebih bisa dipakai nantinya.

12-1. Quick Sort sebagai Algoritma D&C

Langkah Divide: Pilih elemen p (dinamai sebagai pivot)
Lalu partisi (partition) elemen-elemen a[i..j] menjadi tiga bagian: a[i..m-1], a[m], dan a[m+1..j].
a[i..m-1] (kemungkinan kosong) berisi elemen-elemen yang lebih kecil dari p.
a[m] adalah pivot p, indeks m adalah posisi p yang benar didalam larik terurut a nantinya.
a[m+1..j] (kemungkinan kosong) berisi elemen-elemen yang lebih besar atau sama dengan p.
Lalu, urutkan kedua bagian ini secara rekursif.


Langkah Conquer: Jangan kaget... Kita tidak melakukan apa-apa :O!


Jika anda membandingkan ini dengan Merge Sort, anda akan melihat bahwa langkah-langkah D&C dari Quick Sort terbalik total dengan Merge Sort.

12-2. Sub-rutin Penting, O(N) Partition

Kita akan membahas dengan detil algoritma Quick Sort ini dengan pertama-tama membahas sub-rutin terpentingnya: O(N) partition.


Untuk mempartisi a[i..j], kita pertama-tama memilih a[i] sebagai pivot p.

Elemen-elemen sisanya (yaitu a[i+1..j]) terbagi jadi 3 wilayah:

  1. S1 = a[i+1..m] dimana elemen-elemennya < p,
  2. S2 = a[m+1..k-1] dimana elemen-elemennya ≥ p, dan
  3. Tidak diketahui = a[k..j], dimana elemen-elemennya belum dimasukkan ke S1 atau S2.

Diskusi: Kenapa kita memilih p = a[i]? Apakah ada pilihan-pilihan yang lain?


Diskusi yang lebih susah: Apakah baik untuk selalu menaruh item(-item) yang == p selalu ke S2?

12-3. Jawabannya

[This is a hidden slide]

12-4. Partition - Lanjutan

Pada awalnya, region S1 dan S2 dua-duanya kosong, yaitu semua elemen kecuali pivot p yang terpilih berada dalam region yang tidak diketahui.


Lalu, untuk setiap elemen a[k] di region yang tidak diketahui, kita membandingkan a[k] dengan p dan memutuskan satu dari tiga kasus berikut:

  1. Jika a[k] > p, taruh a[k] di S2,
  2. Jika a[k] < p, taruh a[k] di S1,
  3. Jika a[k] == p, lempar sebuah koin dan taruh a[k] ke S1/S2 jika jatuh kepala/ekor, masing-masing.

Ketiga kasus-kasus ini akan dijelaskan lebih detil di dua slide berikutnya.


Pada akhirnya, kita menukar a[i] dan a[m] untuk menaruh pivot p tepat diantara S1 dan S2.

12-5. Partisi - Kasus ketika a[k] > p

Case when a[k] ≥ p, increment k, extend S2 by 1 item

12-6. Partition - Kasus ketika a[k] < p

Case when a[k] < p, increment m, swap a[k] with a[m], increment k, extend S1 by 1 item

12-7. Implementasi C++ dari Partition

int partition(int a[], int i, int j) {
int p = a[i]; // p sebagai pivot
int m = i; // S1 dan S2 pada mulanya kosong
for (int k = i+1; k <= j; ++k) { // jelajah bagian baru
if ((a[k] < p) || ((a[k] == p) && (rand()%2 == 0))){ // case 2+3
++m;
swap(a[k], a[m]); // algoritma C++ STL std::swap
} // kita tidak melakukan apa-apa pada kasus 1: a[k] > p
}
swap(a[i], a[m]); // langkah terakhir, tukar pivot dengan a[m]
return m; // kembalikan indeks pivot
}

12-8. Implementasi C++ dari Quick Sort

void quickSort(int a[], int low, int high) {
if (low < high) {
int m = partition(a, low, high); // O(N)
// a[low..high] ~> a[low..m–1], pivot, a[m+1..high]
quickSort(a, low, m-1); // urutkan sub-larik kiri
// a[m] = pivot telah terurut setelah partition
quickSort(a, m+1, high); // lalu urutkan sub-larik kanan
}
}

12-9. Demonstrasi

Coba Quick Sort pada larik contoh [27, 38, 12, 39, 29, 16]. Kita akan bahas langkah pertama dari partition sebagai berikut:
Kita set p = a[0] = 27.
Kita set a[1] = 38 sebagai bagian S2 jadi S1 = {} dan S2 = {38}.
Kita tukar a[1] = 38 dengan a[2] = 12 jadi S1 = {12} dan S2 = {38}.
Kita set a[3] = 39 dan juga a[4] = 29 berikutnya sebagai bagian S2 jadi S1 = {12} dan S2 = {38,39,29}.
Kita tukar a[2] = 38 dengan a[5] = 16 jadi S1 = {12,16} dan S2 = {39,29,38}.
Kita tukar p = a[0] = 27 dengan a[2] = 16 jadi S1 = {16,12}, p = {27}, dan S2 = {39,29,38}.


Setelah ini, a[2] = 27 dijamin terurut sekarang dan Quick Sort akan mengurutkan secara rekursif sisi kiri a[0..1] duluan dan nanti mengurutkan secara rekursif sisi kanan a[3..5].

12-10. Quick Sort: Analisa Bagian 1

Pertama-tama, kita analisa biaya satu pemanggilan partition.


Didalam partition(a, i, j), hanya ada satu for-loop yang diulang (j-i) kali. Karena j bisa sebesar N-1 dan i bisa sekecil 0, maka kompleksitas waktu dari partition adalah O(N).


Mirip dengan analisa Merge Sort, kompleksitas waktu dari Quick Sort tergantung seberapa banyak partition(a, i, j) dipanggil.

12-11. Quick Sort: Analisa Bagian 2

Ketika larik a sudah dalam urutan menaik, misalkan a = [5, 18, 23, 39, 44, 50}, Quick Sort akan mengatur p = a[0] = 5, dan akan mengembalikan m = 0, oleh karena itu membuat region S1 kosong dan region S2: Semuanya kecuali pivot (N-1 elemen).

12-12. Quick Sort: Analisa Bagian 3

Pada skenario terjelek tersebut, inilah yang terjadi:


Worst Case analysis of Quick Sort

Partisi pertama membutuhkan waktu O(N), membagi a menjadi 0, 1, N-1 elemen-elemen, lalu rekursi ke-kanan.
Yang kedua membutuhkan waktu O(N-1), membagi a menjadi 0, 1, N-2 elemen-elemen, lalu rekursi ke-kanan lagi.
...
Sampai yang terakhir, uartisi ke N membagi a menjadi 0, 1, 1 elemen, dan rekursi Quick Sort berhenti.


Ini adalah pola klasik N+(N-1)+(N-2)+...+1, yang disederhanakan sebagai O(N2), analisa yang mirip dengan yang di slide analisa Bubble Sort ini...

12-13. Quick Sort: Kasus Terbaik (Jarang)

Skenario terbaik dari Quick Sort terjadi ketika partition selalu membagi larik menjadi dua bagian yang sama besar, seperti Merge Sort.


Ketika itu terjadi, kedalaman rekursi hanyalah O(log N).


Karena setiap level membutuhkan O(N) pembandingan, kompleksitas waktu adalah O(N log N).


Coba Quick Sort di contoh larik masukan yang telah dipersiapkan secara khusus [4, 1, 3, 2, 6, 5, 7].

Pada prakteknya, hal ini jarang terjadi, sehingga kita harus memikirkan cara yang lebih baik: Quick Sort Acak.

13. Quick Sort Acak

Sama seperti Quick Sort tetapi sebelum menjalankan algoritma partisi, algoritma ini secara acak memilih sebuah pivot diantara a[i..j] dibandingkan dengan selalu memilih a[i] (atau indeks tetap lainnya diantara [i..j]) secara deterministik.


Latihan kecil: Implementasikan ide diatas pada implementasi yang ditunjukkan di slide ini!


Coba Random Quick Sort pada larik yang besar dan agak acak a = [3,44,38,5,47,15,36,26,27,2,46,4,19,50,48] terasa cepat.

13-1. Analisa "Magis"

Akan dibutuhkan kuliah sekitar 1 jam untuk menjelaskan dengan baik kenapa versi acak dari Quick Sort mempunyai kompleksitas waktu yang diharapkan O(N log N) pada larik masukan apapun dengan N elemen.


Dalam Kuliah Maya ini, kita akan berasumsi bahwa ini benar.


Jika anda membutuhkan penjelasan non formal: Bayangkan bahwa versi acak dari Quick Sort yang mengacak pemilihan pivot, kita tidak akan selalu mendapat pembagian yang sangat jelek yaitu 0 (kosong), 1 (pivot), dan N-1 elemen lainnya. Kombinasi dari beruntung (setengah-pivot-setengah), kira-kira beruntung, kira-kira tidak beruntung, dan sangat tidak beruntung (kosong, pivot, sisanya) menghasilkan kompleksitas waktu rata-rata O(N log N).


Diskusi: Untuk implementasi dari Partisi, apa yang terjadi jika a[k] == p, kita selalu menaruk a[k] pada salah satu sisi (S1 atau S2) secara deterministik?

13-2. Jawabannya

[This is a hidden slide]

14. 2 O(N) Algoritma Tidak Membandingkan

Kita akan membahas dua algoritma-algoritma pengurutan yang tidak berbasis-pembandingan di beberapa slide berikut ini:

  1. Counting Sort,
  2. Radix Sort.

Algoritma-algoritma pengurutan ini bisa lebih cepat dari batas bawah algoritma pengurutan berbasis-pembandingan yaitu Ω(N log N) karena mereka tidak membandingkan elemen-elemen dari larik.

14-1. Batas Bawah dari Algoritma Pengurutan

It is known (also not proven in this visualization as it will take about half-an-hour lecture about decision tree model to do so) that all comparison-based sorting algorithms have a lower bound time complexity of Ω(N log N).


Thus, any comparison-based sorting algorithm with worst-case complexity O(N log N), like Merge Sort is considered an optimal algorithm, i.e., we cannot do better than that.


However, we can achieve faster sorting algorithm — i.e., in O(N) — if certain assumptions of the input array exist and thus we can avoid comparing the items to determine the sorted order.

15. Counting Sort

Assumption: If the items to be sorted are Integers with small range, we can count the frequency of occurrence of each Integer (in that small range) and then loop through that small range to output the items in sorted order.


Try Counting Sort on the example array above where all Integers are within [1..9], thus we just need to count how many times Integer 1 appears, Integer 2 appears, ..., Integer 9 appears, and then loop through 1 to 9 to print out x copies of Integer y if frequency[y] = x.


The time complexity is O(N) to count the frequencies and O(N+k) to print out the output in sorted order where k is the range of the input Integers, which is 9-1+1 = 9 in this example. The time complexity of Counting Sort is thus O(N+k), which is O(N) if k is small.


We will not be able to do the counting part of Counting Sort when k is relatively big due to memory limitation, as we need to store frequencies of those k integers.


PS: This version of Counting Sort is not stable, as it does not actually remember the (input) ordering of duplicate integers. The version presented in CLRS is stable, but is a bit more complex than this form.

16. Radix Sort

Assumption: If the items to be sorted are Integers with large range but of few digits, we can combine Counting Sort idea with Radix Sort to achieve the linear time complexity.


In Radix Sort, we treat each item to be sorted as a string of w digits (we pad Integers that have less than w digits with leading zeroes if necessary).


For the least significant (rightmost) digit to the most significant digit (leftmost), we pass through the N items and put them according to the active digit into 10 Queues (one for each digit [0..9]), which is like a modified Counting Sort as this one preserves stability (remember, the Counting Sort version shown in this slide earlier is not a stable sort). Then we re-concatenate the groups again for subsequent iteration.


Try Radix Sort on the random 4-digits array above for clearer explanation.


Notice that we only perform O(w × (N+k)) iterations. In this example, w = 4 and k = 10.

16-1. Algoritma Pengurutan Terbaik?

Now, having discussed about Radix Sort, should we use it for every sorting situation?


For example, it should be theoretically faster to sort many (N is very large) 32-bit signed integers as w ≤ 10 digits and k = 10 if we interpret those 32-bit signed integers in Decimal. O(10 × (N+10)) = O(N).


Discussion: Using base-10 as shown in this visualization is actually not the best way to sort N 32-bit signed integers. What should be the better setup?

16-2. Jawabannya

[This is a hidden slide]

17. Properti Tambahan dari Algoritma Pengurutan

Ada beberapa properti-properti lain yang bisa digunakan untuk membedakan algoritma-algoritma pengurutan lebih dari sekedar apakah mereka berbasis-pembandingan atau tidak, rekursif atau iteratif.


Dalam bagian ini, kita akan membahas tentang di-tempat dibandingkan dengan tidak di-tempat, stabil dibandingkan dengan tidak stabil, dan performa caching dari berbagai algoritma-algoritma pengurutan.

17-1. Pengurutan Di-Tempat

Sebuah algoritma pengurutan dikatakan sebagai pengurutan di-tempat jika algoritma tersebut hanya membutuhkan sejumlah ruang konstan (yaitu O(1)) selama proses pengurutan. Dengan kata lain, beberapa (konstan) variable-variable ekstra diperbolehkan tetapi kita tidak diperbolehkan untuk menggunakan variable-variable yang mempunyai ukuran tergantung kepada ukuran masukan N.


Merge Sort (versi klasik), karena sub-rutin merge nya membutuhkan larik temporer tambahan dengan ukuran N, tidak di-tempat.


Diskusi: Bagaimana dengan Bubble Sort, Selection Sort, Insertion Sort, Quick Sort (acak maupun tidak), Counting Sort, dan Radix Sort. Yang mana saja yang di-tempat?

17-2. Pengurutan Stabil

A sorting algorithm is called stable if the relative order of elements with the same key value is preserved by the algorithm after sorting is performed.


Example application of stable sort: Assume that we have student names that have been sorted in alphabetical order. Now, if this list is sorted again by tutorial group number (recall that one tutorial group usually has many students), a stable sort algorithm would ensure that all students in the same tutorial group still appear in alphabetical order of their names. Radix sort that goes through multiple round of sorts digit-by-digit requires a stable sort sub-routine for it to work correctly.


Discussion: Which of the sorting algorithms discussed in this e-Lecture are stable?
Try sorting array A = {3, 4a, 2, 4b, 1}, i.e. there are two copies of 4 (4a first, then 4b).

17-3. Performa Cache

[This is a hidden slide]

18. Kuis-Kuis

Kita mendekati akhir dari Kuliah Maya ini.


Waktunya untuk beberapa pertanyaan-pertanyaan sederhana.

18-1. Kuis #1


Quiz: Which of these algorithms run in O(N log N) on any input array of size N?

Quick Sort (Deterministic)
Insertion Sort
Merge Sort
Bubble Sort

18-2. Kuis #2

Quiz: Which of these algorithms has worst case time complexity of Θ(N^2) for sorting N integers?

Merge Sort
Bubble Sort
Selection Sort
Radix Sort
Insertion Sort


Θ adalah analisa kompleksitas waktu yang sudah ketat (tight) dimana analisa kasus terbaik Ω dan kasus terjelek big-O cocok.

19. Tambahan-Tambahan

Kita telah mencapai akhir dari Kuliah Maya pengurutan.


Tetapi, masih ada dua algoritma-algoritma pengurutan lainnya di VisuAlgo yang berada didalam struktur-struktur data yang lain: Heap Sort dan Balanced BST Sort. Kita akan membahas mereka saat anda menjalani Kuliah Maya dari dua struktur-struktur data tersebut.

19-1. Tantangan

[This is a hidden slide]

19-2. Indeks/Perhitungan Inversi

[This is a hidden slide]

19-3. Implementasi

Sebenarnya, kode sumber C++ untuk banyak dari algoritma-algoritma pengurutan ini sudah tersebar di berbagai slide-slide Kuliah Maya. Untuk bahasa pemrograman yang lain, silahkan terjemahkan kode sumber C++ yang diberikan ke bahasa pemrograman lain tersebut.


Biasanya, pengurutan hanyalah bagian kecil dari proses pemecahan masalah dan akhir-akhir ini, banyak bahasa-bahasa pemrograman mempunyai fungsi-fungsi pengurutan mereka sendiri-sendiri sehingga kita tidak perlu untuk mengimplementasikan ulang algoritma-algoritma tersebut kecuali sangat perlu.


Dalam C++, anda bisa menggunakan std::sort (sangat mungkin adalah algoritma pengurutan hibrid: introsort), std::stable_sort (sangat mungkin adalah Merge Sort), atau std::partial_sort (sangat mungkin adalah Timbunan Biner) dalam STL algorithm.
Dalam Python, anda bisa menggunakan sort (sangat mungkin adalah algoritma pengurutan hibrid: Timsort).
Dalam Java, anda bisa menggunakan Collections.sort.

Dalam OCaml, anda bisa menggunakan List.sort compare list_name.


Jika fungsi pembandingan adalah spesifik ke sebuah masalah, kita mungkin harus memberikan fungsi pembandingan tambahan kepada rutin pengurutan yang sudah built-in tersebut.

19-4. Kuis Online

Sekarang saatnya bagi anda untuk melihat apakah anda telah mengerti dasar-dasar dari berbagi algoritma-algoritma pengurutan yang dibahas sejauh ini.


Test your understanding here!

19-5. Latihan-Latihan Online Judge

Sekarang setelah anda mencapai akhir dari Kuliah Maya ini, apakah anda pikir masalah pengurutan sesimpel pemanggilan rutin pengurutan yang sudah built-in di berbagai bahasa pemrograman?


Cobalah masalah-masalah di online judge ini untuk menyelidiki lebih lanjut:
Kattis - mjehuric
Kattis - sortofsorting, atau
Kattis - sidewayssorting


Ini bukan akhir dari topik pengurutan. Ketika anda menjelajahi topik-topik lain di VisuAlgo, anda akan menyadari bahwa pengurutan adalah langkah pre-processing untuk banyak algoritma-algoritma tingkat lanjut lainnya untuk menyelesaikan masalah-masalah yang lebih sulit, contohnya sebagai langkah pre-processing untuk algoritma Kruskal, secara kreatif dipakai didalam struktur data Larik Akhiran (Suffix Array), dsb.