`) +// Output: ['

', ''] +``` + +#### Contoh 2: Teks dengan Banyak Level +```typescript +const text = `THIS IS SAMPLE(MAIN hoge(ITEM fuga)(ITEM2 nogami(ABBR)))` + +parseNestedBrackets(text, '(', ')') +// Output: +// [ +// '(MAIN hoge(ITEM fuga)(ITEM2 nogami(ABBR)))', // Level 1 +// '(ITEM fuga)', // Level 2 +// '(ITEM2 nogami(ABBR))', // Level 2 +// '(ABBR)' // Level 3 +// ] +``` + +#### Contoh 3: Ekspresi Matematika +```typescript +const expr = "(2 + (3 * (4 + 5)))" + +parseNestedBrackets(expr, '(', ')') +// Output: +// [ +// '(2 + (3 * (4 + 5)))', // Level 1 +// '(3 * (4 + 5))', // Level 2 +// '(4 + 5)' // Level 3 +// ] +``` + +### 🎯 Visualisasi Proses + +``` +Input: "(A(B(C)D)E)" + +Iterasi per karakter: + +Posisi: 0 1 2 3 4 5 6 7 8 9 +Teks: ( A ( B ( C ) D ) E ) + ↑ + Floor = 1, begin = 0 + +Posisi: 0 1 2 3 4 5 6 7 8 9 +Teks: ( A ( B ( C ) D ) E ) + ↑ + Floor = 2 + +Posisi: 0 1 2 3 4 5 6 7 8 9 +Teks: ( A ( B ( C ) D ) E ) + ↑ + Floor = 3 + +Posisi: 0 1 2 3 4 5 6 7 8 9 +Teks: ( A ( B ( C ) D ) E ) + ↑ + Floor = 2 (ketemu ')', turun) + +Posisi: 0 1 2 3 4 5 6 7 8 9 +Teks: ( A ( B ( C ) D ) E ) + ↑ + Floor = 1 (ketemu ')', turun) + Simpan: "(B(C)D)" + +Posisi: 0 1 2 3 4 5 6 7 8 9 10 +Teks: ( A ( B ( C ) D ) E ) + ↑ + Floor = 0 (ketemu ')', turun) + Simpan: "(A(B(C)D)E)" + +Hasil akhir: ['(A(B(C)D)E)', '(B(C)D)', '(C)'] +``` + +### ⏱️ Kompleksitas + +| Kasus | Waktu | Ruang | +|-------|-------|-------| +| Time | O(n) | Setiap karakter diproses sekali | +| Space | O(d) | d = kedalaman maksimum nesting | + +--- + +## 3️⃣ Shuffle Array (Fisher-Yates) - Acak Array + +### 📝 Apa itu? + +Algoritma untuk **mengacak elemen array secara acak** dengan distribusi yang **seragam** (setiap kemungkinan urutan memiliki probabilitas yang sama). + +### 🤔 Kenapa Fisher-Yates Lebih Baik? + +| Metode | Masalah | +|--------|---------| +| `sort(() => Math.random() - 0.5)` | ❌ Tidak seragam! Ada bias | +| Fisher-Yates | ✅ Seragam, efisien, terbukti matematis | + +**Masalah dengan `sort()` + `random()`:** +- JavaScript sort tidak guarantee stabilitas dengan comparator random +- Beberapa urutan lebih mungkin muncul daripada yang lain +- Bisa sangat lambat untuk array besar + +### 💡 Logika Kerja Fisher-Yates + +``` +Array awal: [1, 2, 3, 4, 5] + +Langkah 1: Pilih index acak dari 0-4, swap dengan index 4 + [1, 2, 3, 5, 4] ← 5 dan 4 ditukar + +Langkah 2: Pilih index acak dari 0-3, swap dengan index 3 + [1, 2, 5, 3, 4] ← 3 dan 5 ditukar + +Langkah 3: Pilih index acak dari 0-2, swap dengan index 2 + [1, 5, 2, 3, 4] ← 2 dan 5 ditukar + +Langkah 4: Pilih index acak dari 0-1, swap dengan index 1 + [5, 1, 2, 3, 4] ← 1 dan 5 ditukar + +Done! Array sudah teracak: [5, 1, 2, 3, 4] +``` + +### 🔧 Implementasi Kode + +```typescript +/** + * @function shuffleArray + * @description Mengacak array menggunakan algoritma Fisher-Yates. + * Algoritma ini menghasilkan permutasi acak yang seragam. + * + * @param {number[]} arr - Array yang akan diacak (in-place) + * @returns {void} - Array dimodifikasi langsung + * + * @example + * const cards = [1, 2, 3, 4, 5] + * shuffleArray(cards) + * console.log(cards) // [3, 1, 5, 2, 4] (acak) + */ +export function shuffleArray(arr: number[]) { + // Mulai dari belakang, bergerak ke depan + for (let i = arr.length - 1; i > 0; i--) { + // Pilih index acak dari 0 sampai i (inklusif) + const j = Math.floor(Math.random() * (i + 1)) + + // Tukar elemen di index i dengan elemen di index j + const temp = arr[i] + arr[i] = arr[j] + arr[j] = temp + } +} +``` + +### 📊 Contoh Penggunaan + +```typescript +// 🎴 Mengacak kartu +const deck = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] +shuffleArray(deck) +console.log(deck) // [7, 2, 10, 1, 5, 3, 9, 4, 6, 8] (acak!) + +// 🎲 Mengacak dadu virtual +const dice = [1, 2, 3, 4, 5, 6] +shuffleArray(dice) +console.log(dice[0]) // Ambil hasil acak pertama + +// 📝 Mengacak urutan pertanyaan quiz +const questions = ['Q1', 'Q2', 'Q3', 'Q4', 'Q5'] +shuffleArray(questions) +// Setiap siswa dapat urutan pertanyaan yang berbeda! +``` + +### 🎨 Visualisasi Detail + +``` +Array: [A, B, C, D, E] +Index: 0 1 2 3 4 + +═══════════════════════════════════════════════════ + +Iterasi 1: i = 4 (elemen terakhir) +┌─────────────────────────────────────────────────┐ +│ Pilih j acak dari 0 sampai 4 │ +│ Misal: j = 2 │ +│ │ +│ Sebelum: [A, B, C, D, E] │ +│ ↑ ↑ │ +│ j=2 i=4 │ +│ │ +│ Swap C dan E │ +│ Sesudah: [A, B, E, D, C] ← C sudah fix di pos 4│ +└─────────────────────────────────────────────────┘ + +Iterasi 2: i = 3 +┌─────────────────────────────────────────────────┐ +│ Pilih j acak dari 0 sampai 3 │ +│ Misal: j = 0 │ +│ │ +│ Sebelum: [A, B, E, D, C] │ +│ ↑ ↑ │ +│ j=0 i=3 │ +│ │ +│ Swap A dan D │ +│ Sesudah: [D, B, E, A, C] ← A sudah fix di pos 3│ +└─────────────────────────────────────────────────┘ + +Iterasi 3: i = 2 +┌─────────────────────────────────────────────────┐ +│ Pilih j acak dari 0 sampai 2 │ +│ Misal: j = 2 │ +│ │ +│ Sebelum: [D, B, E, A, C] │ +│ ↑ │ +│ j=2, i=2 (sama!) │ +│ │ +│ Swap E dengan E (tetap) │ +│ Sesudah: [D, B, E, A, C] ← E fix di pos 2 │ +└─────────────────────────────────────────────────┘ + +Iterasi 4: i = 1 +┌─────────────────────────────────────────────────┐ +│ Pilih j acak dari 0 sampai 1 │ +│ Misal: j = 1 │ +│ │ +│ Sebelum: [D, B, E, A, C] │ +│ ↑ │ +│ j=1, i=1 (sama!) │ +│ │ +│ Swap B dengan B (tetap) │ +│ Sesudah: [D, B, E, A, C] ← B fix di pos 1 │ +└─────────────────────────────────────────────────┘ + +Iterasi 5: i = 0 +┌─────────────────────────────────────────────────┐ +│ i = 0, loop berhenti (i > 0) │ +│ D sudah fix di pos 0 secara otomatis │ +└─────────────────────────────────────────────────┘ + +═══════════════════════════════════════════════════ + +Hasil Akhir: [D, B, E, A, C] ✅ +``` + +### 🎯 Kenapa Ini Bekerja? + +**Sifat penting Fisher-Yates:** + +1. **Unbiased (Tidak Bias)**: Setiap permutasi memiliki probabilitas `1/n!` +2. **In-place**: Tidak membutuhkan array tambahan +3. **O(n)**: Linear time, sangat efisien + +**Matematika sederhana:** +- Array dengan n elemen punya `n!` (n faktorial) kemungkinan urutan +- Fisher-Yates menghasilkan setiap urutan dengan probabilitas `1/n!` +- Ini adalah distribusi seragam yang sempurna! 🎯 + +### ⏱️ Kompleksitas + +| Metrik | Nilai | Keterangan | +|--------|-------|------------| +| Time | O(n) | Satu pass melalui array | +| Space | O(1) | In-place, no extra memory | +| Random Calls | n-1 | Satu per iterasi | + +### ⚠️ Catatan Penting + +```typescript +// ❌ SALAH: Bisa menghasilkan bias +arr.sort(() => Math.random() - 0.5) + +// ✅ BENAR: Fisher-Yates, seragam +shuffleArray(arr) + +// ❌ SALAH: Mengembalikan array baru (tidak in-place) +function wrongShuffle(arr) { + return [...arr].sort(() => Math.random() - 0.5) +} + +// ✅ BENAR: In-place modification +shuffleArray(arr) // arr langsung berubah +``` + +--- + +## 🍼 Resume Bahasa Bayi (Simple Summary) + +### Is Sorted Array 👶 +> "Cek satu-satu, kalau ada yang lebih besar dari sebelahnya, berarti berantakan!" + +Simpelnya: Jalankan dari depan ke belakang, kalau ketemu angka yang lebih besar dari angka sebelah kanannya, berarti tidak terurut. + +--- + +### Parse Nested Brackets 👶 +> "Hitung buka tutup kurung, masuk ruangan = naik lantai, keluar = turun lantai!" + +Simpelnya: Setiap ketemu bracket buka, naik 1 lantai. Ketemu bracket tutup, turun 1 lantai. Kalau lagi di lantai 1 terus ketemu bracket tutup, berarti ketemu satu grup lengkap! + +--- + +### Shuffle Array (Fisher-Yates) 👶 +> "Ambil dari belakang, tukar sama yang di depan secara acak, ulangi!" + +Simpelnya: Mulai dari belakang, pilih satu elemen secara acak dari depan sampai posisi sekarang, lalu tukar. Ulangi sampai semua ketukar! + +--- + +## 📚 Referensi + +- [Fisher-Yates Shuffle - Wikipedia](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle) +- [Stack-based Parsing - GeeksforGeeks](https://www.geeksforgeeks.org/check-for-balanced-parentheses-in-an-expression/) +- [The Algorithms - TypeScript](https://github.com/TheAlgorithms/TypeScript) + +--- + +

+ +**[⬆ Kembali ke Atas](#-utility-algorithms---algoritma-utilitas)** + +*Dibuat dengan ❤️ untuk pemula yang ingin belajar algoritma* + +

diff --git a/search/README.md b/search/README.md new file mode 100644 index 00000000..d1e6b31b --- /dev/null +++ b/search/README.md @@ -0,0 +1,1140 @@ +# 🔍 Search Algorithms (Algoritma Pencarian) + +Selamat datang di panduan lengkap algoritma pencarian! Dokumen ini akan membantu kamu memahami berbagai cara mencari data dalam array, dari yang paling sederhana hingga yang lebih canggih. + +--- + +## 📚 Daftar Isi + +1. [Pengenalan Search Algorithms](#1-pengenalan-search-algorithms) +2. [Tabel Perbandingan Kompleksitas](#2-tabel-perbandingan-kompleksitas) +3. [Penjelasan Detail Setiap Algoritma](#3-penjelasan-detail-setiap-algoritma) + - [Linear Search](#31-linear-search) + - [Sentinel Search](#32-sentinel-search) + - [Binary Search](#33-binary-search) + - [Jump Search](#34-jump-search) + - [Interpolation Search](#35-interpolation-search) + - [Exponential Search](#36-exponential-search) + - [Fibonacci Search](#37-fibonacci-search) +4. [Resume Bahasa Bayi](#4-resume-bahasa-bayi) + +--- + +## 1. Pengenalan Search Algorithms + +### Apa itu Search Algorithm? + +**Search Algorithm** (Algoritma Pencarian) adalah serangkaian langkah yang digunakan untuk menemukan posisi (index) dari sebuah nilai tertentu di dalam kumpulan data (array). + +### Kenapa Perlu Berbeda-beda? + +> "Kenapa nggak pakai satu cara aja?" + +Bayangkan kamu mencari buku: +- **Di meja berantakan** → Cek satu per satu (Linear Search) +- **Di rak buku tersusun rapi** → Buka tengah, bandingkan, potong setengah (Binary Search) +- **Di perpustakaan besar** → Loncat-loncat dulu, baru cari detail (Jump Search) + +**Setiap situasi butuh strategi berbeda!** + +### Prasyarat Penting + +| Algoritma | Array Harus Terurut? | Catatan | +|-----------|---------------------|---------| +| Linear Search | ❌ Tidak | Bisa untuk array acak | +| Sentinel Search | ❌ Tidak | Variasi linear search | +| Binary Search | ✅ Ya | Wajib terurut! | +| Jump Search | ✅ Ya | Wajib terurut! | +| Interpolation Search | ✅ Ya | Wajib terurut + data merata | +| Exponential Search | ✅ Ya | Wajib terurut! | +| Fibonacci Search | ✅ Ya | Wajib terurut! | + +--- + +## 2. Tabel Perbandingan Kompleksitas + +### 📊 Ringkasan Big O Notation + +| Algoritma | Best Case | Average Case | Worst Case | Space | Array Terurut? | +|-----------|-----------|--------------|------------|-------|----------------| +| **Linear Search** | O(1) | O(n) | O(n) | O(1) | ❌ Tidak | +| **Sentinel Search** | O(1) | O(n) | O(n) | O(1) | ❌ Tidak | +| **Binary Search** | O(1) | O(log n) | O(log n) | O(1)* | ✅ Ya | +| **Jump Search** | O(1) | O(√n) | O(√n) | O(1) | ✅ Ya | +| **Interpolation Search** | O(1) | O(log log n) | O(n) | O(1) | ✅ Ya | +| **Exponential Search** | O(1) | O(log n) | O(log n) | O(1)* | ✅ Ya | +| **Fibonacci Search** | O(1) | O(log n) | O(log n) | O(1) | ✅ Ya | + +\* *Versi recursive membutuhkan O(log n) space untuk call stack* + +### 🎯 Kapan Menggunakan Apa? + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ PANDUAN MEMILIH ALGORITMA │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ ┌─────────────────┐ │ +│ │ Array kecil │──→ Linear Search (sederhana & cepat) │ +│ │ (< 50 elemen) │ │ +│ └─────────────────┘ │ +│ │ +│ ┌─────────────────┐ │ +│ │ Array besar │──→ Binary Search (paling umum & stabil) │ +│ │ terurut │ │ +│ └─────────────────┘ │ +│ │ +│ ┌─────────────────┐ │ +│ │ Target di awal │──→ Exponential Search (optimal) │ +│ │ array besar │ │ +│ └─────────────────┘ │ +│ │ +│ ┌─────────────────┐ │ +│ │ Data terurut │──→ Interpolation Search (bisa super cepat) │ +│ │ & merata │ │ +│ └─────────────────┘ │ +│ │ +│ ┌─────────────────┐ │ +│ │ Akses elemen │──→ Fibonacci Search (lebih sedikit │ +│ │ mahal (disk) │ perbandingan) │ +│ └─────────────────┘ │ +│ │ +└─────────────────────────────────────────────────────────────────┘ +``` + +--- + +## 3. Penjelasan Detail Setiap Algoritma + +--- + +### 3.1 Linear Search + +#### 📖 Definisi +Linear Search adalah algoritma pencarian paling sederhana. Caranya: **cek elemen satu per satu dari awal sampai akhir** sampai menemukan target. + +#### 🎯 Kapan Digunakan +- Array kecil (kurang dari 50 elemen) +- Array yang **tidak terurut** +- Hanya butuh pencarian sekali-kali +- Implementasi harus super sederhana + +#### 🔄 Cara Kerja + +``` +Array: [10, 50, 30, 70, 20] +Target: 70 + +Langkah 1: Cek index 0 → 10 ≠ 70 ❌ +Langkah 2: Cek index 1 → 50 ≠ 70 ❌ +Langkah 3: Cek index 2 → 30 ≠ 70 ❌ +Langkah 4: Cek index 3 → 70 = 70 ✅ DITEMUKAN! + +Hasil: Index 3 +``` + +#### 🎨 Visualisasi + +``` +Pencarian 70 dalam array: + +Index: 0 1 2 3 4 + ┌─────┬─────┬─────┬─────┬─────┐ +Array: │ 10 │ 50 │ 30 │ 70 │ 20 │ + └─────┴─────┴─────┴─────┴─────┘ + ↑ + Cek 10 ≠ 70 + + ┌─────┬─────┬─────┬─────┬─────┐ + │ 10 │ 50 │ 30 │ 70 │ 20 │ + └─────┴─────┴─────┴─────┴─────┘ + ↑ + Cek 50 ≠ 70 + + ┌─────┬─────┬─────┬─────┬─────┐ + │ 10 │ 50 │ 30 │ 70 │ 20 │ + └─────┴─────┴─────┴─────┴─────┘ + ↑ + Cek 30 ≠ 70 + + ┌─────┬─────┬─────┬─────┬─────┐ + │ 10 │ 50 │ 30 │ 70 │ 20 │ + └─────┴─────┴─────┴─────┴─────┘ + ↑ + Cek 70 = 70 ✅ + DITEMUKAN! +``` + +#### 💻 Implementasi Kode + +```typescript +export const linearSearch = (array: any[], target: any): number => { + for (let i = 0; i < array.length; i++) { + if (array[i] === target) return i // Ketemu! + } + return -1 // Tidak ketemu +} + +// Penggunaan: +linearSearch([10, 50, 30, 70, 20], 70) // Returns: 3 +linearSearch([10, 50, 30, 70, 20], 99) // Returns: -1 +``` + +#### ⏱️ Analisis Kompleksitas +- **Best Case**: O(1) → Target di index pertama +- **Worst Case**: O(n) → Target di index terakhir atau tidak ada +- **Average Case**: O(n) → Target di tengah-tengah + +--- + +### 3.2 Sentinel Search + +#### 📖 Definisi +Sentinel Search adalah variasi Linear Search yang lebih efisien. Triknya: **tambahkan target di akhir array** (sebagai "penjaga") sehingga kita tidak perlu cek batas array di setiap iterasi. + +#### 🎯 Kapan Digunakan +- Array tidak terurut +- Ingin sedikit lebih cepat dari Linear Search biasa +- Boleh mengubah array sementara + +#### 🔄 Cara Kerja + +``` +Array: [10, 50, 30, 70, 20] +Target: 70 + +Langkah 1: Simpan elemen terakhir (20) +Langkah 2: Ganti elemen terakhir dengan target (70) + Array menjadi: [10, 50, 30, 70, 70] + +Langkah 3: Cari dari awal, tanpa cek batas array! + Index 0: 10 ≠ 70 + Index 1: 50 ≠ 70 + Index 2: 30 ≠ 70 + Index 3: 70 = 70 ✅ + +Langkah 4: Kembalikan elemen terakhir (20) +Langkah 5: Cek: index 3 < panjang-1? Ya! → Return 3 +``` + +#### 🎨 Visualisasi + +``` +Pencarian 70 dengan Sentinel: + +Array asli: +┌─────┬─────┬─────┬─────┬─────┐ +│ 10 │ 50 │ 30 │ 70 │ 20 │ ← Simpan 20 +└─────┴─────┴─────┴─────┴─────┘ + +Pasang sentinel (70 di akhir): +┌─────┬─────┬─────┬─────┬─────┐ +│ 10 │ 50 │ 30 │ 70 │ 70 │ ← Sentinel (penjaga) +└─────┴─────┴─────┴─────┴─────┘ + ↑ + Target pasti ketemu di sini + kalau tidak di tempat lain + +Cari tanpa cek batas: + ↓ +┌─────┬─────┬─────┬─────┬─────┐ +│ 10 │ 50 │ 30 │ 70 │ 70 │ +└─────┴─────┴─────┴─────┴─────┘ + ↓ +┌─────┬─────┬─────┬─────┬─────┐ +│ 10 │ 50 │ 30 │ 70 │ 70 │ +└─────┴─────┴─────┴─────┴─────┘ + ↓ +┌─────┬─────┬─────┬─────┬─────┐ +│ 10 │ 50 │ 30 │ 70 │ 70 │ +└─────┴─────┴─────┴─────┴─────┘ + ↓ +┌─────┬─────┬─────┬─────┬─────┐ +│ 10 │ 50 │ 30 │ 70 │ 70 │ ← KETEMU! Index 3 +└─────┴─────┴─────┴─────┴─────┘ + +Kembalikan array asli: +┌─────┬─────┬─────┬─────┬─────┐ +│ 10 │ 50 │ 30 │ 70 │ 20 │ ← 20 kembali +└─────┴─────┴─────┴─────┴─────┘ +``` + +#### 💻 Implementasi Kode + +```typescript +export const sentinelSearch = ( + array: number[], + target: number +): number | null => { + const arrayLength = array.length + if (arrayLength === 0) return null + + // Simpan elemen terakhir + const last = array[arrayLength - 1] + + // Pasang sentinel + array[arrayLength - 1] = target + + let index: number = 0 + // Loop tanpa cek batas array! + while (array[index] !== target) { + index += 1 + } + + // Kembalikan elemen terakhir + array[arrayLength - 1] = last + + // Cek apakah ketemu di array asli atau di sentinel + if (index < arrayLength - 1 || array[arrayLength - 1] === target) { + return index + } + return null +} +``` + +#### 💡 Keuntungan +- **Hemat 1 comparison per iterasi** (tidak perlu cek `i < array.length`) +- Lebih cepat untuk array besar + +--- + +### 3.3 Binary Search + +#### 📖 Definisi +Binary Search adalah algoritma pencarian super cepat untuk array **terurut**. Strateginya: **bagi array jadi dua, bandingkan dengan tengah, buang setengah yang tidak mungkin**. + +#### 🎯 Kapan Digunakan +- Array **sudah terurut** +- Array besar +- Pencarian sering dilakukan +- Butuh performa O(log n) + +#### 🔄 Cara Kerja + +``` +Array terurut: [10, 20, 30, 40, 50, 60, 70, 80] +Target: 60 + +Langkah 1: Cari tengah → index 3 (nilai 40) + 60 > 40? Ya! → Cari di kanan: [50, 60, 70, 80] + +Langkah 2: Cari tengah kanan → index 5 (nilai 60) + 60 = 60? Ya! ✅ DITEMUKAN! + +Hanya 2 langkah untuk array 8 elemen! +``` + +#### 🎨 Visualisasi + +``` +Pencarian 60 dalam array terurut: + +Array: [10, 20, 30, 40, 50, 60, 70, 80] +Index: 0 1 2 3 4 5 6 7 + +Iterasi 1: +┌───────────────────────────────────────────────┐ +│ 10 20 30 40 50 60 70 80 │ +│ 0 1 2 3 4 5 6 7 │ +│ ↑ ↑ ↑ │ +│ start middle end │ +│ (40) │ +└───────────────────────────────────────────────┘ + +60 > 40? Ya! → Cari di kanan + +Iterasi 2: +┌───────────────────────────────────────────────┐ +│ 50 60 70 80 │ +│ 4 5 6 7 │ +│ ↑ │ +│ middle │ +│ (60) │ +└───────────────────────────────────────────────┘ + +60 = 60? Ya! ✅ KETEMU di index 5! + + +Visualisasi pemotongan: + + [10, 20, 30, 40, 50, 60, 70, 80] + ↓ + ┌─────────┴─────────┐ + [10,20,30,40] [50,60,70,80] + < 60 dibuang ≥ 60 dicari + ↓ + ┌─────┴─────┐ + [50,60] [70,80] + ≤60 >60 + dicari dibuang + ↓ + ┌─┴─┐ + [50] [60] + <60 =60 + dibuang ✅ +``` + +#### 💻 Implementasi Kode + +**Versi Iterative:** +```typescript +export const binarySearchIterative = ( + array: number[], + target: number, + start: number = 0, + end: number = array.length - 1 +): number | null => { + if (array.length === 0) return null + + // Pastikan target dalam rentang array + if (target < array[start] || target > array[end]) return null + + let middle = (start + end) >> 1 // Sama dengan Math.floor((start+end)/2) + + while (array[middle] !== target && start <= end) { + if (target < array[middle]) { + end = middle - 1 // Cari di kiri + } else { + start = middle + 1 // Cari di kanan + } + middle = (start + end) >> 1 + } + + return array[middle] === target ? middle : null +} +``` + +**Versi Recursive:** +```typescript +export const binarySearchRecursive = ( + array: number[], + target: number, + start = 0, + end = array.length - 1 +): number | null => { + if (array.length === 0) return null + if (target < array[start] || target > array[end]) return null + + const middle = (start + end) >> 1 + + if (array[middle] === target) return middle + if (start > end) return null + + return target < array[middle] + ? binarySearchRecursive(array, target, start, middle - 1) + : binarySearchRecursive(array, target, middle + 1, end) +} + +// Penggunaan: +binarySearchIterative([10, 20, 30, 40, 50, 60, 70, 80], 60) // Returns: 5 +binarySearchRecursive([10, 20, 30, 40, 50, 60, 70, 80], 25) // Returns: null +``` + +#### ⏱️ Analisis Kompleksitas +- **Best Case**: O(1) → Target persis di tengah +- **Worst Case**: O(log n) → Target di ujung atau tidak ada +- **Space**: O(1) iterative, O(log n) recursive + +#### 📊 Kecepatan Binary Search + +``` +Ukuran Array Maksimum Langkah +──────────────────────────────── +10 4 +100 7 +1,000 10 +1,000,000 20 +1,000,000,000 30 +``` + +--- + +### 3.4 Jump Search + +#### 📖 Definisi +Jump Search adalah algoritma untuk array terurut yang **melompat-lompat** dengan langkah tetap (biasanya √n), lalu mencari linear di blok yang tepat. + +#### 🎯 Kapan Digunakan +- Array terurut besar +- Akses sequential lebih cepat dari random (seperti linked list) +- Ingin kompleksitas O(√n) + +#### 🔄 Cara Kerja + +``` +Array: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160] +Target: 110 + +Step size = √16 = 4 + +Langkah 1: Lompat 4 elemen + Index 3: 40 < 110? Ya, lanjut! + Index 7: 80 < 110? Ya, lanjut! + Index 11: 120 > 110? Ya, stop! + +Langkah 2: Cari linear dari index 8 ke 11 + Index 8: 90 ≠ 110 + Index 9: 100 ≠ 110 + Index 10: 110 = 110 ✅ DITEMUKAN! +``` + +#### 🎨 Visualisasi + +``` +Pencarian 110 dengan Jump Search: + +Array: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160] +Index: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 + +Step = √16 = 4 + +Lompatan 1: ↓ + ┌─────┐ + │ 40 │ < 110? Ya, lompat! + └─────┘ + +Lompatan 2: ↓ + ┌─────┐ + │ 80 │ < 110? Ya, lompat! + └─────┘ + +Lompatan 3: ↓ + ┌─────┐ + │ 120 │ > 110? Ya, stop! + └─────┘ + +Blok yang mungkin: dari index 8 sampai 11 + +Cari linear: + [90, 100, 110, 120] + 8 9 10 11 + + 90 ≠ 110 + 100 ≠ 110 + 110 = 110 ✅ KETEMU! + + +Visualisasi grid: +┌─────────┬─────────┬─────────┬─────────┐ +│ 10-40 │ 50-80 │ 90-120 │ 130-160 │ +│ [0-3] │ [4-7] │ [8-11] │ [12-15] │ +│ ❌ │ ❌ │ ✅ │ │ +└─────────┴─────────┴─────────┴─────────┘ + ↑ + Target ada di sini +``` + +#### 💻 Implementasi Kode + +```typescript +export const jumpSearch = (array: number[], target: number): number => { + if (array.length === 0) return -1 + + // Step optimal = akar kuadrat dari panjang array + const stepSize: number = Math.floor(Math.sqrt(array.length)) + let currentIdx: number = 0 + let nextIdx: number = stepSize + + // Lompat-lompat sampai ketemu blok yang tepat + while (array[nextIdx - 1] < target) { + currentIdx = nextIdx + nextIdx += stepSize + + if (nextIdx > array.length) { + nextIdx = array.length + break + } + } + + // Cari linear di blok tersebut + for (let index = currentIdx; index < nextIdx; index++) { + if (array[index] == target) { + return index + } + } + + return -1 +} + +// Penggunaan: +jumpSearch([10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120], 110) +// Returns: 10 +``` + +#### ⏱️ Analisis Kompleksitas +- **Best Case**: O(1) → Target di lompatan pertama +- **Worst Case**: O(√n) → Target di blok terakhir +- **Space**: O(1) + +--- + +### 3.5 Interpolation Search + +#### 📖 Definisi +Interpolation Search adalah Binary Search yang lebih pintar! Kalau Binary Search selalu cek tengah, Interpolation Search **menebak posisi berdasarkan nilai target** (seperti mencari kata di kamus). + +#### 🎯 Kapan Digunakan +- Array terurut dengan data **merata/seragam** +- Data angka yang tersebar merata +- Bisa sangat cepat: O(log log n) + +#### 🔄 Cara Kerja + +``` +Array: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100] +Target: 70 + +Rumus posisi: +pos = low + ((target - arr[low]) × (high - low)) / (arr[high] - arr[low]) + +Iterasi 1: +low=0, high=9 +pos = 0 + ((70-10) × (9-0)) / (100-10) + = 0 + (60 × 9) / 90 + = 0 + 540 / 90 + = 6 + +Index 6 = 70? Ya! ✅ Langsung ketemu! + +Hanya 1 langkah! (Binary Search butuh 2-3 langkah) +``` + +#### 🎨 Visualisasi + +``` +Pencarian 70 dengan Interpolation Search: + +Array: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100] +Index: 0 1 2 3 4 5 6 7 8 9 + ↑ ↑ + low high + +Karena data merata, kita bisa "menebak": + +10 ──────────────────────────────────────── 100 +↑ ↑ +0 9 + +70 ada di mana? + ↓ +10 ─────── 70 ─────────────────────────── 100 + ↑ + (70-10)/(100-10) = 60/90 = 2/3 + + 2/3 dari jarak = index sekitar 6 + +Cek index 6: +┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐ +│ 10 │ 20 │ 30 │ 40 │ 50 │ 60 │ 70 │ 80 │ 90 │ 100 │ +└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘ + ↑ + Index 6 = 70 ✅ + LANGSUNG KETEMU! + + +Perbandingan dengan Binary Search: + +Interpolation Search (data merata): +┌─────────────────────────────────────────────────────────┐ +│ Target 70 → Tebak index 6 → Langsung ketemu! (1 step) │ +└─────────────────────────────────────────────────────────┘ + +Binary Search (data sama): +┌─────────────────────────────────────────────────────────┐ +│ Target 70 → Cek index 4 (50) → Cek index 7 (80) │ +│ → Cek index 5 (60) → Cek index 6 (70) │ +│ → 4 steps │ +└─────────────────────────────────────────────────────────┘ +``` + +#### 💻 Implementasi Kode + +```typescript +export const interpolationSearch = ( + array: number[], + target: number +): number => { + let lowIndex: number = 0 + let highIndex: number = array.length - 1 + + while (lowIndex <= highIndex) { + const lowValue: number = array[lowIndex] + const highValue: number = array[highIndex] + + // Hindari pembagian dengan nol + if (lowValue === highValue) { + if (array[lowIndex] === target) { + return lowIndex + } + break + } + + // Rumus interpolasi untuk menebak posisi + const pos = Math.round( + lowIndex + + ((target - lowValue) * (highIndex - lowIndex)) / (highValue - lowValue) + ) + + if (pos < 0 || pos >= array.length) break + + const currentValue = array[pos] + + if (target === currentValue) { + return pos // Ketemu! + } + + if (target > currentValue) { + lowIndex = pos + 1 // Cari di kanan + } else { + highIndex = pos - 1 // Cari di kiri + } + } + + return -1 +} + +// Penggunaan: +interpolationSearch([10, 20, 30, 40, 50, 60, 70, 80, 90, 100], 70) +// Returns: 6 +``` + +#### ⚠️ Catatan Penting +- **Terbaik untuk data merata** (arithmetic progression) +- **Terburuk untuk data tidak merata**: bisa jadi O(n) +- Contoh data buruk: [1, 2, 3, 4, 1000000] + +--- + +### 3.6 Exponential Search + +#### 📖 Definisi +Exponential Search (atau Galloping Search) adalah algoritma yang **mencari dengan langkah eksponensial** (1, 2, 4, 8, 16...) untuk menemukan rentang, lalu Binary Search di dalamnya. + +#### 🎯 Kapan Digunakan +- Array terurut besar +- Target kemungkinan besar ada di **awal array** +- Array unbounded (tak terbatas/tidak tahu ukuran) + +#### 🔄 Cara Kerja + +``` +Array: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, ...] +Target: 30 + +Fase 1: Cari rentang dengan loncat eksponensial + i=1: cek index 1 → 20 < 30? Ya, lanjut! (i=2) + i=2: cek index 2 → 30 = 30? Ya! ✅ KETEMU! + +Kalau belum ketemu, terus sampai arr[i] > target: + i=4: cek index 4 → 50 > 30? Ya! Stop! + Rentang: index 2 sampai 4 + +Fase 2: Binary Search di rentang [2, 4] + ... +``` + +#### 🎨 Visualisasi + +``` +Pencarian 30 dengan Exponential Search: + +Array: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, ...] +Index: 0 1 2 3 4 5 6 7 8 9 + +Fase 1: Lompat eksponensial + + i=1: + ┌──────────────────────────────────────────┐ + │ 10 20 30 40 50 60 ... │ + │ 0 1 2 3 4 5 │ + │ ↑ │ + │ index 1 = 20 < 30? Ya, lompat! │ + └──────────────────────────────────────────┘ + + i=2: + ┌──────────────────────────────────────────┐ + │ 10 20 30 40 50 60 ... │ + │ 0 1 2 3 4 5 │ + │ ↑ │ + │ index 2 = 30 = 30? Ya! ✅ │ + └──────────────────────────────────────────┘ + + KETEMU! Hanya 2 pengecekan! + + +Contoh kalau target lebih jauh (cari 70): + + i=1: index 1 = 20 < 70? Ya! (i=2) + i=2: index 2 = 30 < 70? Ya! (i=4) + i=4: index 4 = 50 < 70? Ya! (i=8) + i=8: index 8 = 90 > 70? Ya! Stop! + + Rentang: index 4 sampai 8 + + ┌──────────────────────────────────────────┐ + │ ... 50 60 70 80 90 ... │ + │ 4 5 6 7 8 │ + │ └────────────────┘ │ + │ Binary Search di sini │ + └──────────────────────────────────────────┘ + + +Visualisasi loncatan: + +Start: i=1 + ↓ +[10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120] + ↑ + i=2 (×2) + +[10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120] + ↑ + i=4 (×2) + +[10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120] + ↑ + i=8 (×2) +``` + +#### 💻 Implementasi Kode + +```typescript +import { binarySearchIterative } from './binary_search' + +export const exponentialSearch = ( + array: number[], + x: number +): number | null => { + const arrayLength = array.length + if (arrayLength === 0) return null + + // Cek elemen pertama + if (array[0] === x) return 0 + + // Fase 1: Cari rentang dengan loncat eksponensial + let i = 1 + while (i < arrayLength && array[i] <= x) { + i = i * 2 // Gandakan: 1, 2, 4, 8, 16... + } + + // Fase 2: Binary Search di rentang yang ditemukan + const start = Math.floor(i / 2) + const end = Math.min(i, arrayLength - 1) + + return binarySearchIterative(array, x, start, end) +} + +// Penggunaan: +exponentialSearch([10, 20, 30, 40, 50, 60, 70, 80], 30) // Returns: 2 +``` + +#### ⏱️ Analisis Kompleksitas +- **Best Case**: O(1) → Target di index 0 +- **Worst Case**: O(log n) → Sama dengan Binary Search +- **Space**: O(1) + +#### 💡 Keuntungan +- **Lebih cepat** kalau target di awal array +- Bisa digunakan untuk array yang ukurannya tidak diketahui (unbounded) + +--- + +### 3.7 Fibonacci Search + +#### 📖 Definima +Fibonacci Search menggunakan **bilangan Fibonacci** (0, 1, 1, 2, 3, 5, 8, 13...) untuk membagi array. Mirip Binary Search, tapi menggunakan ukuran Fibonacci untuk pembagian. + +#### 🎯 Kapan Digunakan +- Array terurut besar +- Akses elemen mahal (misal: data di disk) +- Ingin mengurangi perbandingan elemen + +#### 🔄 Cara Kerja + +``` +Array: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110] +Panjang: 11 + +Langkah 1: Cari bilangan Fibonacci ≥ 11 + 0, 1, 1, 2, 3, 5, 8, 13 ← 13 adalah yang pertama ≥ 11 + + fibM = 13 (n) + fibM2 = 5 (n-2) + fibM1 = 8 (n-1) + +Langkah 2: Bandingkan dengan elemen di index fibM2 = 5 + arr[5] = 60 + Target 80 > 60? Ya! + + Geser: fibM=8, fibM1=5, fibM2=3 + Offset = 5 + +Langkah 3: Bandingkan dengan index offset + fibM2 = 5 + 3 = 8 + arr[8] = 90 + Target 80 < 90? Ya! + + Geser: fibM=5, fibM1=3, fibM2=2 + +Langkah 4: Bandingkan dengan index 5 + 2 = 7 + arr[7] = 80 + Target 80 = 80? Ya! ✅ +``` + +#### 🎨 Visualisasi + +``` +Pencarian 80 dengan Fibonacci Search: + +Array: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110] +Index: 0 1 2 3 4 5 6 7 8 9 10 + +Bilangan Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13 + ↑ ↑ ↑ + f2 f1 fm (13 ≥ 11) + +Iterasi 1: +┌─────────────────────────────────────────────────────────┐ +│ 10 20 30 40 50 60 70 80 90 100 110 │ +│ 0 1 2 3 4 5 6 7 8 9 10 │ +│ ↑ │ +│ index 5 = 60 │ +│ 80 > 60? Ya → Kanan │ +└─────────────────────────────────────────────────────────┘ + +Update: fm=8, fm1=5, fm2=3, offset=5 + +Iterasi 2: +┌─────────────────────────────────────────────────────────┐ +│ 70 80 90 100 110 │ +│ 6 7 8 9 10 │ +│ ↑ │ +│ index 5+3=8 = 90 │ +│ 80 < 90? Ya → Kiri │ +└─────────────────────────────────────────────────────────┘ + +Update: fm=5, fm1=3, fm2=2 + +Iterasi 3: +┌─────────────────────────────────────────────────────────┐ +│ 70 80 │ +│ 6 7 │ +│ ↑ │ +│ index 5+2=7 = 80 │ +│ 80 = 80? Ya! ✅ │ +└─────────────────────────────────────────────────────────┘ + + +Visualisasi pembagian Fibonacci: + + ┌─────────────────────────┐ + │ Array (11 elemen) │ + │ fm = 13 │ + └─────────────────────────┘ + │ + ┌─────────┴─────────┐ + │ │ + fm2=5 fm1=8 +┌─────────┐ ┌───────────────┐ +│ Kiri │ │ Kanan │ +│ 5 elem │ │ 8 elem │ +│ │ │ │ +│dibuang │ │ dicari │ +│(kecil) │ │ │ +└─────────┘ └───────────────┘ + │ + ┌──────┴──────┐ + │ │ + fm2=3 fm1=5 + ┌───────┐ ┌───────────┐ + │ Kiri │ │ Kanan │ + │(kecil)│ │ dicari │ + └───────┘ └───────────┘ + │ + ...dst +``` + +#### 💻 Implementasi Kode + +```typescript +export const fibonacciSearch = ( + array: number[], + target: number +): number | null => { + const arrayLength = array.length + + // Inisialisasi bilangan Fibonacci + let a = 0 // (n-2)'th Fibonacci + let b = 1 // (n-1)'th Fibonacci + let c = a + b // n'th Fibonacci + + // Cari bilangan Fibonacci terkecil yang ≥ panjang array + while (c < arrayLength) { + a = b + b = c + c = a + b + } + + let offset = -1 + + // Cari dengan membagi menggunakan Fibonacci + while (c > 1) { + let i = Math.min(offset + a, arrayLength - 1) + + if (array[i] < target) { + // Cari di kanan + c = b + b = a + a = c - b + offset = i + } else if (array[i] > target) { + // Cari di kiri + c = a + b = b - a + a = c - b + } else { + return i // Ketemu! + } + } + + // Cek elemen terakhir + if (b && array[offset + 1] === target) { + return offset + 1 + } + + return null +} + +// Penggunaan: +fibonacciSearch([10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110], 80) +// Returns: 7 +``` + +#### ⏱️ Analisis Kompleksitas +- **Time**: O(log n) +- **Space**: O(1) + +#### 💡 Keuntungan +- **Lebih sedikit perbandingan** elemen dibanding Binary Search +- Cocok untuk akses elemen yang mahal (misal: pencarian di disk) + +--- + +## 4. Resume Bahasa Bayi + +### 🍼 Untuk Pemula yang Baru Belajar + +> "Bang, ribet amat! Kasih yang simpel dong!" + +Oke, ini versi super sederhana: + +--- + +### 📱 Analogi HP (Handphone) + +| Algoritma | Analogi HP | +|-----------|-----------| +| **Linear Search** | Cek kontak satu per satu dari A sampai Z | +| **Sentinel Search** | Sama kayak Linear, tapi pasang "bookmark" biar gak kelewatan | +| **Binary Search** | Buka kontak di tengah, kalau nama lebih besar, scroll ke atas, kalau lebih kecil scroll ke bawah | +| **Jump Search** | Scroll loncat-loncat 10 kontak sekali, kalau kelewatan, scroll balik sedikit | +| **Interpolation Search** | Kalau cari "Budi", langsung ke bagian B, gak usah dari tengah | +| **Exponential Search** | Scroll 1, 2, 4, 8 kontak... sampai kelewatan, baru cari detail | +| **Fibonacci Search** | Mirip Binary Search, tapi pakai pola khusus biar lebih efisien | + +--- + +### 🎯 Cheat Sheet Cepat + +``` +┌────────────────────────────────────────────────────────────────┐ +│ CHEAT SHEET SEARCH │ +├────────────────────────────────────────────────────────────────┤ +│ │ +│ ❓ ARRAY BELUM TERURUT? │ +│ → Pake LINEAR SEARCH atau SENTINEL SEARCH │ +│ │ +│ ❓ ARRAY SUDAH TERURUT + KECIL (< 50)? │ +│ → Pake LINEAR SEARCH aja (gampang) │ +│ │ +│ ❓ ARRAY SUDAH TERURUT + BESAR? │ +│ → Pake BINARY SEARCH (paling umum) │ +│ │ +│ ❓ TARGET DI AWAL ARRAY BESAR? │ +│ → Pake EXPONENTIAL SEARCH │ +│ │ +│ ❓ DATA ANGKA MERATA (10,20,30,40...)? │ +│ → Pake INTERPOLATION SEARCH (bisa super cepat!) │ +│ │ +│ ❓ AKSES DATA MAHAL (kayak di hard disk)? │ +│ → Pake FIBONACCI SEARCH │ +│ │ +│ ❓ PAKE LINKED LIST? │ +│ → Pake JUMP SEARCH │ +│ │ +└────────────────────────────────────────────────────────────────┘ +``` + +--- + +### 🧠 Yang Perlu Diingat + +1. **Linear Search = Dasar banget** + - Cocok untuk semua array (terurut maupun tidak) + - Lambat untuk data besar + - Gampang diingat dan diimplementasi + +2. **Binary Search = Andalan** + - WAJIB array terurut! + - Cepat banget: O(log n) + - Paling sering dipakai di dunia kerja + +3. **Yang Lain = Variasi** + - Interpolation: Cepat kalau data merata + - Exponential: Cepat kalau target di awal + - Fibonacci: Hemat resource + - Jump: Cocok untuk linked list + +--- + +### 📝 Contoh Kasus Nyata + +```typescript +// Kasus 1: Cari user di database kecil (belum terurut) +const users = ['budi', 'ani', 'citra', 'dodi'] +linearSearch(users, 'citra') // ✅ Pake Linear + +// Kasus 2: Cari angka di array besar terurut +const numbers = [1, 3, 5, 7, 9, ..., 999999] +binarySearch(numbers, 500000) // ✅ Pake Binary + +// Kasus 3: Cari ID produk yang baru ditambahkan (di awal log) +const logs = [1001, 1002, 1003, ..., 9999] +exponentialSearch(logs, 1002) // ✅ Pake Exponential + +// Kasus 4: Cari nilai ujian yang terdistribusi merata +const scores = [10, 20, 30, 40, ..., 100] +interpolationSearch(scores, 70) // ✅ Pake Interpolation +``` + +--- + +### 🚀 Tips Belajar + +1. **Kuasai Linear Search dulu** → Dasar semua algoritma +2. **Lanjut Binary Search** → Yang paling sering dipakai +3. **Baru yang lainnya** → Untuk kasus khusus + +> "Gak usah hafal semua, yang penting paham konsepnya!" + +--- + +## 📚 Referensi + +- [GeeksforGeeks - Searching Algorithms](https://www.geeksforgeeks.org/searching-algorithms/) +- [Wikipedia - Search Algorithm](https://en.wikipedia.org/wiki/Search_algorithm) + +--- + +**Selamat belajar! 🎉** + +*Semoga dokumentasi ini membantu kamu memahami algoritma pencarian dengan mudah!* diff --git a/sorts/README.md b/sorts/README.md new file mode 100644 index 00000000..e81f3682 --- /dev/null +++ b/sorts/README.md @@ -0,0 +1,1768 @@ +# 📚 Sorting Algorithms - Algoritma Pengurutan + +> Panduan lengkap memahami algoritma pengurutan dengan penjelasan sederhana, visualisasi, dan contoh kode TypeScript. + +--- + +## 📋 Daftar Isi + +1. [Pengenalan Sorting Algorithms](#1-pengenalan-sorting-algorithms) +2. [Perbandingan Kompleksitas](#2-perbandingan-kompleksitas) +3. [Penjelasan Detail Setiap Algoritma](#3-penjelasan-detail-setiap-algoritma) + - [Bubble Sort](#bubble-sort) + - [Selection Sort](#selection-sort) + - [Insertion Sort](#insertion-sort) + - [Merge Sort](#merge-sort) + - [Quick Sort](#quick-sort) + - [Heap Sort](#heap-sort) + - [Counting Sort](#counting-sort) + - [Shell Sort](#shell-sort) + - [Gnome Sort](#gnome-sort) + - [Cycle Sort](#cycle-sort) + - [Bogo Sort](#bogo-sort) + - [Tree Sort](#tree-sort) + - [Quick Select](#quick-select) + - [Swap Sort](#swap-sort) +4. [Resume Bahasa Bayi](#4-resume-bahasa-bayi) + +--- + +## 1. Pengenalan Sorting Algorithms + +### Apa itu Sorting? + +**Sorting (Pengurutan)** adalah proses menyusun data dalam urutan tertentu, biasanya dari yang terkecil ke terbesar (**ascending**) atau sebaliknya (**descending**). + +### Mengapa Sorting Penting? + +``` +🎯 Contoh sehari-hari: +├── 📱 Kontak di HP - diurutkan berdasarkan nama +├── 🛒 E-commerce - harga termurah ke termahal +├── 📊 Nilai siswa - ranking dari tertinggi +└── 🔍 Pencarian Google - hasil paling relevan +``` + +### Kategori Algoritma Sorting + +``` +┌─────────────────────────────────────────────────────────┐ +│ KATEGORI ALGORITMA SORTING │ +├─────────────────────────────────────────────────────────┤ +│ │ +│ 🔵 Simple Sorts (O(n²)) │ +│ ├── Bubble Sort │ +│ ├── Selection Sort │ +│ └── Insertion Sort │ +│ │ +│ 🟢 Efficient Sorts (O(n log n)) │ +│ ├── Merge Sort │ +│ ├── Quick Sort │ +│ └── Heap Sort │ +│ │ +│ 🟡 Distribution Sorts │ +│ └── Counting Sort │ +│ │ +│ 🟣 Specialized Sorts │ +│ ├── Shell Sort │ +│ ├── Gnome Sort │ +│ ├── Cycle Sort │ +│ ├── Bogo Sort │ +│ └── Tree Sort │ +│ │ +│ 🔴 Selection/Utility │ +│ ├── Quick Select │ +│ └── Swap Sort │ +│ │ +└─────────────────────────────────────────────────────────┘ +``` + +--- + +## 2. Perbandingan Kompleksitas + +### 📊 Tabel Perbandingan Lengkap + +| Algoritma | Best Case | Average Case | Worst Case | Space | Stabil | Metode | +|-----------|-----------|--------------|------------|-------|--------|--------| +| **Bubble Sort** | O(n) | O(n²) | O(n²) | O(1) | ✅ Ya | Comparison | +| **Selection Sort** | O(n²) | O(n²) | O(n²) | O(1) | ❌ Tidak | Comparison | +| **Insertion Sort** | O(n) | O(n²) | O(n²) | O(1) | ✅ Ya | Comparison | +| **Merge Sort** | O(n log n) | O(n log n) | O(n log n) | O(n) | ✅ Ya | Divide & Conquer | +| **Quick Sort** | O(n log n) | O(n log n) | O(n²) | O(log n) | ❌ Tidak | Divide & Conquer | +| **Heap Sort** | O(n log n) | O(n log n) | O(n log n) | O(1) | ❌ Tidak | Comparison | +| **Counting Sort** | O(n + k) | O(n + k) | O(n + k) | O(k) | ✅ Ya | Distribution | +| **Shell Sort** | O(n log n) | O(n log² n) | O(n²) | O(1) | ❌ Tidak | Insertion Variant | +| **Gnome Sort** | O(n) | O(n²) | O(n²) | O(1) | ✅ Ya | Comparison | +| **Cycle Sort** | O(n²) | O(n²) | O(n²) | O(1) | ❌ Tidak | Comparison | +| **Bogo Sort** | O(n) | O(n! × n) | ∞ | O(1) | ❌ Tidak | Random | +| **Tree Sort** | O(n log n) | O(n log n) | O(n²)* | O(n) | ✅ Ya | BST | +| **Quick Select** | O(n) | O(n) | O(n²) | O(1) | - | Selection | +| **Swap Sort** | O(n log n) | O(n log n) | O(n log n) | O(n) | - | Utility | + +> *Tree Sort worst case O(n²) terjadi jika tree menjadi skewed (mirip linked list) + +### 🎨 Visualisasi Kinerja + +``` +Kecepatan (Semakin cepat → semakin kecil nilai) + +O(n log n) ████████████████████ Merge Sort, Quick Sort*, Heap Sort + ████████████████████ + +O(n) ████████ Counting Sort (k kecil) + ████████ + +O(n²) ████████████████████████████████████████████████ + Bubble, Selection, Insertion, Gnome, Cycle + +O(n! × n) ████████████████████████████████████████████████████████████████ + ████████████████████████████████████████████████████████████████ Bogo Sort + ████████████████████████████████████████████████████████████████ + +* Quick Sort worst case O(n²) +``` + +--- + +## 3. Penjelasan Detail Setiap Algoritma + +--- + +### Bubble Sort + +#### Definisi +Bubble Sort adalah algoritma pengurutan paling sederhana. Ia bekerja dengan **membandingkan pasangan elemen bersebelahan** dan menukar posisinya jika urutannya salah. Proses ini berulang sampai seluruh array terurut. + +#### Cara Kerja Step-by-Step + +``` +Array awal: [5, 3, 8, 1, 2] + +🔁 Pass 1: + [5, 3, 8, 1, 2] → 5 > 3? Ya, tukar! → [3, 5, 8, 1, 2] + [3, 5, 8, 1, 2] → 5 > 8? Tidak → [3, 5, 8, 1, 2] + [3, 5, 8, 1, 2] → 8 > 1? Ya, tukar! → [3, 5, 1, 8, 2] + [3, 5, 1, 8, 2] → 8 > 2? Ya, tukar! → [3, 5, 1, 2, 8] ✓ 8 di posisi akhir + +🔁 Pass 2: + [3, 5, 1, 2, 8] → 3 > 5? Tidak → [3, 5, 1, 2, 8] + [3, 5, 1, 2, 8] → 5 > 1? Ya, tukar! → [3, 1, 5, 2, 8] + [3, 1, 5, 2, 8] → 5 > 2? Ya, tukar! → [3, 1, 2, 5, 8] ✓ 5 di posisi benar + +🔁 Pass 3: + [3, 1, 2, 5, 8] → 3 > 1? Ya, tukar! → [1, 3, 2, 5, 8] + [1, 3, 2, 5, 8] → 3 > 2? Ya, tukar! → [1, 2, 3, 5, 8] ✓ 3 di posisi benar + +🔁 Pass 4: + [1, 2, 3, 5, 8] → Sudah terurut! Selesai. + +Hasil akhir: [1, 2, 3, 5, 8] ✅ +``` + +#### Implementasi Kode + +```typescript +export const bubbleSort = (arr: number[]): number[] => { + for (let i = 0; i < arr.length; i++) { + for (let j = 0; j < arr.length - 1; j++) { + // Bandingkan elemen bersebelahan + if (arr[j] > arr[j + 1]) { + // Tukar posisi jika tidak terurut + const temp: number = arr[j] + arr[j] = arr[j + 1] + arr[j + 1] = temp + } + } + } + return arr +} +``` + +#### Visualisasi ASCII Art + +``` +Sebelum Sorting: + 8 3 5 1 4 2 + █ █ █ █ █ █ + █ █ █ █ █ █ + █ █ █ █ █ █ + █ █ █ █ █ █ + █ █ █ █ █ █ + █ █ █ █ █ █ + █ █ █ █ █ █ + █ █ █ █ █ █ + █ █ █ █ █ █ + +Bubble naik ke atas seperti gelembung! + + ↓ ↓ ↓ ↓ ↓ ↓ + 1 2 3 4 5 8 + █ █ █ █ █ █ +``` + +#### Kapan Digunakan + +| ✅ Cocok Digunakan | ❌ Tidak Cocok | +|-------------------|----------------| +| Data sudah hampir terurut | Data besar (>1000 elemen) | +| Belajar konsep sorting | Performa penting | +| Data kecil (<50 elemen) | - | + +--- + +### Selection Sort + +#### Definisi +Selection Sort bekerja dengan **memilih elemen terkecil** dari bagian yang belum terurut dan **menukarnya ke posisi paling depan** dari bagian tersebut. + +#### Cara Kerja Step-by-Step + +``` +Array awal: [64, 25, 12, 22, 11] + +🔍 Pass 1 - Cari minimum dari index 0-4: + [64, 25, 12, 22, 11] + ↑________________↑ + min = 11 + Tukar index 0 dengan index 4: + [11, 25, 12, 22, 64] ✓ 11 sudah fix di posisi 0 + +🔍 Pass 2 - Cari minimum dari index 1-4: + [11, 25, 12, 22, 64] + ↑_________↑ + min = 12 + Tukar index 1 dengan index 2: + [11, 12, 25, 22, 64] ✓ 12 sudah fix di posisi 1 + +🔍 Pass 3 - Cari minimum dari index 2-4: + [11, 12, 25, 22, 64] + ↑_____↑ + min = 22 + Tukar index 2 dengan index 3: + [11, 12, 22, 25, 64] ✓ 22 sudah fix di posisi 2 + +🔍 Pass 4 - Cari minimum dari index 3-4: + [11, 12, 22, 25, 64] + ↑__↑ + min = 25 (sudah di posisi benar) + Tidak perlu tukar! + +Hasil akhir: [11, 12, 22, 25, 64] ✅ +``` + +#### Implementasi Kode + +```typescript +export const selectionSort = (items: number[]) => { + for (let i = 0; i < items.length; i++) { + let min = i // Asumsikan elemen ke-i adalah minimum + + // Cari elemen terkecil di sisa array + for (let j = i + 1; j < items.length; j++) { + if (items[j] < items[min]) { + min = j // Update index minimum + } + } + + // Tukar elemen ke-i dengan elemen minimum + if (i !== min) { + [items[i], items[min]] = [items[min], items[i]] + } + } + return items +} +``` + +#### Visualisasi ASCII Art + +``` +Proses Selection Sort: + +[64, 25, 12, 22, 11] ← Array awal + │ + └──→ Cari terkecil: 11 + Tukar! + +[11, 25, 12, 22, 64] ← 11 ✅ (sudah fix) + │ + └──→ Cari terkecil: 12 + Tukar! + +[11, 12, 25, 22, 64] ← 12 ✅ (sudah fix) + │ + └──→ Cari terkecil: 22 + Tukar! + +[11, 12, 22, 25, 64] ← 22 ✅ (sudah fix) + │ + └──→ 25 sudah benar! + +[11, 12, 22, 25, 64] ✅ TERURUT! +``` + +#### Kapan Digunakan + +| ✅ Cocok Digunakan | ❌ Tidak Cocok | +|-------------------|----------------| +| Memori terbatas (in-place) | Data besar | +| Minimalkan jumlah swap | Butuh sorting stabil | +| Data kecil | - | + +--- + +### Insertion Sort + +#### Definisi +Insertion Sort bekerja seperti menyusun kartu di tangan. Ambil satu kartu, lalu **sisipkan ke posisi yang tepat** di antara kartu yang sudah terurut. + +#### Cara Kerja Step-by-Step + +``` +Array awal: [4, 3, 2, 10, 12, 1, 5, 6] + +🎯 Mulai dari index 1 (anggap index 0 sudah terurut) + +🔁 Pass 1 - key = 3: + [4 | 3, 2, 10, 12, 1, 5, 6] ← | = batas terurut/belum + ↑ ↑ + 4 > 3? Ya, geser 4 ke kanan + [3, 4 | 2, 10, 12, 1, 5, 6] ✓ + +🔁 Pass 2 - key = 2: + [3, 4 | 2, 10, 12, 1, 5, 6] + ↑ ↑ + 4 > 2? Ya, geser + 3 > 2? Ya, geser + Sisipkan 2 di depan: + [2, 3, 4 | 10, 12, 1, 5, 6] ✓ + +🔁 Pass 3 - key = 10: + [2, 3, 4 | 10, 12, 1, 5, 6] + ↑ ↑ + 4 > 10? Tidak, 10 sudah di posisi benar + [2, 3, 4, 10 | 12, 1, 5, 6] ✓ + +🔁 Pass 4 - key = 12: + [2, 3, 4, 10 | 12, 1, 5, 6] + ↑ ↑ + 10 > 12? Tidak, 12 sudah di posisi benar + [2, 3, 4, 10, 12 | 1, 5, 6] ✓ + +🔁 Pass 5 - key = 1: + [2, 3, 4, 10, 12 | 1, 5, 6] + Geser semua yang lebih besar: + [1, 2, 3, 4, 10, 12 | 5, 6] ✓ + +... (lanjut sampai selesai) + +Hasil akhir: [1, 2, 3, 4, 5, 6, 10, 12] ✅ +``` + +#### Implementasi Kode + +```typescript +export const insertionSort = (arr: number[]): number[] => { + for (let i = 1; i < arr.length; i++) { + const key = arr[i] // Elemen yang akan disisipkan + let j = i - 1 + + // Geser elemen yang lebih besar dari key + while (j >= 0 && arr[j] > key) { + arr[j + 1] = arr[j] + j-- + } + + // Sisipkan key di posisi yang tepat + arr[j + 1] = key + } + return arr +} +``` + +#### Visualisasi ASCII Art + +``` +Menyusun kartu seperti di tangan: + +Langkah 0: [4] ← Ambil kartu pertama + +Langkah 1: [4] ← 3 ← Ambil 3 + [3, 4] ← Sisipkan sebelum 4 + +Langkah 2: [3, 4] ← 2 ← Ambil 2 + [2, 3, 4] ← Sisipkan di depan + +Langkah 3: [2, 3, 4] ← 10 ← Ambil 10 + [2, 3, 4, 10] ← Sisipkan di belakang + +Langkah 4: [2, 3, 4, 10] ← 1 ← Ambil 1 + [1, 2, 3, 4, 10] ← Sisipkan di depan + +Hasil: [1, 2, 3, 4, 10] ✅ +``` + +#### Kapan Digunakan + +| ✅ Cocok Digunakan | ❌ Tidak Cocok | +|-------------------|----------------| +| Data sudah hampir terurut | Data besar dan acak | +| Data masuk secara streaming | - | +| Array kecil (< 50 elemen) | - | + +--- + +### Merge Sort + +#### Definisi +Merge Sort menggunakan pendekatan **Divide and Conquer** (Bagi dan Taklukkan): +1. **Divide**: Bagi array menjadi dua bagian +2. **Conquer**: Urutkan masing-masing bagian secara rekursif +3. **Merge**: Gabungkan dua bagian yang sudah terurut + +#### Cara Kerja Step-by-Step + +``` +Array awal: [38, 27, 43, 3, 9, 82, 10] + +📦 DIVIDE (Bagi): + [38, 27, 43, 3, 9, 82, 10] + / \ + [38, 27, 43, 3] [9, 82, 10] + / \ / \ + [38, 27] [43, 3] [9, 82] [10] + / \ / \ / \ + [38] [27] [43] [3] [9] [82] [10] + +🔁 CONQUER & MERGE (Urutkan & Gabung): + + [38] [27] [43] [3] [9] [82] [10] + \ / \ / \ / | + [27, 38] [3, 43] [9, 82] [10] + \ / \ / + [3, 27, 38, 43] [9, 10, 82] + \ / + [3, 9, 10, 27, 38, 43, 82] ✅ + +Proses Merge detail: +[27, 38] + [3, 43]: + 27 vs 3 → ambil 3 → [3] + 27 vs 43 → ambil 27 → [3, 27] + 38 vs 43 → ambil 38 → [3, 27, 38] + sisa 43 → ambil 43 → [3, 27, 38, 43] +``` + +#### Implementasi Kode + +```typescript +export function mergeSort(array: number[]): number[] { + // Base case: array dengan 0 atau 1 elemen sudah terurut + if (array.length <= 1) return array.slice() + + // Divide: Bagi array menjadi dua + const midIndex = Math.floor(array.length / 2) + const left = array.slice(0, midIndex) + const right = array.slice(midIndex, array.length) + + // Conquer: Urutkan rekursif, lalu merge + return merge(mergeSort(left), mergeSort(right)) +} + +function merge(left: number[], right: number[]): number[] { + const result: number[] = [] + let leftIndex = 0 + let rightIndex = 0 + + // Bandingkan dan gabungkan + while (leftIndex < left.length && rightIndex < right.length) { + if (left[leftIndex] < right[rightIndex]) { + result.push(left[leftIndex++]) + } else { + result.push(right[rightIndex++]) + } + } + + // Tambahkan sisa elemen + return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex)) +} +``` + +#### Visualisasi ASCII Art + +``` +Merge Sort Visualization: + + [8, 3, 5, 1, 4, 2] + | + +-------+-------+ + | | + [8, 3, 5] [1, 4, 2] + | | + +---+---+ +---+---+ + | | | | + [8, 3] [5] [1, 4] [2] + | | + +-+-+ +-+-+ + | | | | + [8] [3] [1] [4] + + [8] [3] → merge → [3, 8] + [3, 8] + [5] → merge → [3, 5, 8] + + [1] [4] → merge → [1, 4] + [1, 4] + [2] → merge → [1, 2, 4] + + [3, 5, 8] + [1, 2, 4] → merge → [1, 2, 3, 4, 5, 8] ✅ +``` + +#### Kapan Digunakan + +| ✅ Cocok Digunakan | ❌ Tidak Cocok | +|-------------------|----------------| +| Data besar | Memori terbatas (butuh O(n) extra space) | +| Butuh sorting stabil | Data kecil (overhead rekursi) | +| Linked list | - | + +--- + +### Quick Sort + +#### Definisi +Quick Sort juga menggunakan **Divide and Conquer**. Pilih elemen **pivot**, lalu partisi array menjadi: +- Elemen **lebih kecil** dari pivot (kiri) +- Elemen **lebih besar** dari pivot (kanan) + +Lalu urutkan kedua bagian secara rekursif. + +#### Cara Kerja Step-by-Step + +``` +Array awal: [10, 80, 30, 90, 40, 50, 70] + +🔀 Pilih pivot = 70 (elemen terakhir) + +Partisi: + [10, 80, 30, 90, 40, 50 | 70] + ↑ ↑ + i=0 pivot + + 10 < 70? Ya, i++ → i=1 + 80 < 70? Tidak, lanjut + 30 < 70? Ya, tukar 80↔30, i++ → i=2 + [10, 30, 80, 90, 40, 50 | 70] + ↑ + 90 < 70? Tidak, lanjut + 40 < 70? Ya, tukar 80↔40, i++ → i=3 + [10, 30, 40, 90, 80, 50 | 70] + ↑ + 50 < 70? Ya, tukar 90↔50, i++ → i=4 + [10, 30, 40, 50, 80, 90 | 70] + ↑ + Tukar pivot ke posisi i: + [10, 30, 40, 50 | 70 | 80, 90] + <70 pivot >70 + +🔁 Rekursif pada kiri dan kanan: + [10, 30, 40, 50] dan [80, 90] + + ... (proses berulang) + +Hasil akhir: [10, 30, 40, 50, 70, 80, 90] ✅ +``` + +#### Implementasi Kode + +```typescript +export const QuickSort = ( + array: number[], + left: number = 0, + right: number = array.length - 1 +): number[] => { + if (array.length > 1) { + const index = partition(array, left, right) + + // Rekursif pada bagian kiri + if (left < index - 1) { + QuickSort(array, left, index - 1) + } + + // Rekursif pada bagian kanan + if (index + 1 < right) { + QuickSort(array, index + 1, right) + } + } + return array +} + +export const partition = ( + array: number[], + left: number = 0, + right: number = array.length - 1 +) => { + const pivotIndex = choosePivot(left, right) + const pivot = array[pivotIndex] + + // Pindahkan pivot ke akhir + [array[pivotIndex], array[right]] = [array[right], array[pivotIndex]] + + let i = left - 1 + let j = right + + while (i < j) { + while (array[++i] < pivot); + while (array[--j] > pivot); + + if (i < j) { + [array[i], array[j]] = [array[j], array[i]] + } + } + + // Pindahkan pivot ke posisi akhir + [array[right], array[i]] = [array[i], array[right]] + return i +} +``` + +#### Visualisasi ASCII Art + +``` +Quick Sort - Divide and Conquer: + +[10, 80, 30, 90, 40, 50, 70] + pivot = 70 + +Partisi: +┌─────────────────────────────────────┐ +│ [10, 30, 40, 50] 70 [80, 90] │ +│ < pivot pivot > pivot │ +└─────────────────────────────────────┘ + +Rekursif kiri: +[10, 30, 40, 50] pivot = 50 +[10, 30, 40] 50 [] → [10, 30, 40, 50] + +Rekursif kanan: +[80, 90] pivot = 90 +[80] 90 [] → [80, 90] + +Gabung: [10, 30, 40, 50, 70, 80, 90] ✅ +``` + +#### Kapan Digunakan + +| ✅ Cocok Digunakan | ❌ Tidak Cocok | +|-------------------|----------------| +| Array besar | Data sudah terurut (worst case) | +| Array di memory (random access) | Butuh sorting stabil | +| Performa umum terbaik | - | + +--- + +### Heap Sort + +#### Definisi +Heap Sort menggunakan struktur data **Binary Heap** (pohon biner khusus). +- **Max Heap**: Parent lebih besar dari children +- Proses: Build heap → Extract max → Heapify ulang + +#### Cara Kerja Step-by-Step + +``` +Array awal: [4, 10, 3, 5, 1] + +🏗️ Step 1: Build Max Heap + + Visualisasi Tree: + 4 10 10 + / \ → / \ → / \ + 10 3 4 3 5 3 + / \ / \ / + 5 1 5 1 4 1 + + Array: [4, 10, 3, 5, 1] → [10, 5, 3, 4, 1] + +🔄 Step 2: Extract & Heapify + + [10, 5, 3, 4, 1] + ↑ ↑ + max swap + + [1, 5, 3, 4 | 10] ← 10 sudah fix di akhir + + Heapify [1, 5, 3, 4]: + 1 5 + / \ → / \ + 5 3 1 3 + / / + 4 4 + + [5, 4, 3, 1 | 10] + ↑ ↑ + swap max + + [1, 4, 3 | 5, 10] ← 5 sudah fix + + ... (ulangi sampai selesai) + +Hasil akhir: [1, 3, 4, 5, 10] ✅ +``` + +#### Implementasi Kode + +```typescript +export const HeapSort = (arr: number[]): number[] => { + // Bangun max heap + buildMaxHeap(arr) + + // Extract elemen satu per satu + for (let i = arr.length - 1; i > 0; i--) { + swap(arr, 0, i) // Pindahkan root (max) ke akhir + heapify(arr, 0, i) // Heapify sisa heap + } + + return arr +} + +function buildMaxHeap(arr: number[]): void { + const n = arr.length + // Mulai dari parent terakhir + for (let i = Math.floor(n / 2) - 1; i >= 0; i--) { + heapify(arr, i, n) + } +} + +function heapify(arr: number[], index: number, size: number): void { + let largest = index + const left = 2 * index + 1 + const right = 2 * index + 2 + + // Cari yang terbesar antara parent, left, right + if (left < size && arr[left] > arr[largest]) { + largest = left + } + if (right < size && arr[right] > arr[largest]) { + largest = right + } + + // Jika largest bukan parent, tukar dan heapify lagi + if (largest !== index) { + swap(arr, index, largest) + heapify(arr, largest, size) + } +} +``` + +#### Visualisasi ASCII Art + +``` +Max Heap Structure: + + 10 5 + / \ → / \ + 5 3 4 3 + / / + 4 1 + +[10, 5, 3, 4, 1] [5, 4, 3, 1] + [10] + + 5 4 + / \ → / \ + 4 3 1 3 + / + 1 + +[5, 4, 3, 1, 10] [4, 1, 3] + [5, 10] + +... (sampai terurut) + +[1, 3, 4, 5, 10] ✅ +``` + +#### Kapan Digunakan + +| ✅ Cocok Digunakan | ❌ Tidak Cocok | +|-------------------|----------------| +| Memori terbatas (in-place O(1)) | Butuh sorting stabil | +| Guarantee O(n log n) | Cache performance kurang baik | +| Priority Queue implementation | - | + +--- + +### Counting Sort + +#### Definisi +Counting Sort adalah **non-comparison sort**. Ia menghitung frekuensi setiap elemen, lalu menghitung posisi akhir berdasarkan kumulatif frekuensi. + +#### Cara Kerja Step-by-Step + +``` +Array awal: [4, 2, 2, 8, 3, 3, 1], range 1-8 + +📝 Step 1: Count frekuensi + + Index: 0 1 2 3 4 5 6 7 8 + Count: [0, 1, 2, 2, 1, 0, 0, 0, 1] + ↑ ↑ ↑ ↑ ↑ + 1 2 3 4 8 + + Artinya: 1 muncul 1x, 2 muncul 2x, dst. + +📊 Step 2: Cumulative Count + + Count: [0, 1, 3, 5, 6, 6, 6, 6, 7] + ↑ ↑ ↑ ↑ ↑ + │ │ │ │ └── 8 ada di posisi 7 + │ │ │ └── 4 ada di posisi 6 + │ │ └── 3 ada di posisi 5 + │ └── 2 ada di posisi 3 + └── 1 ada di posisi 1 + +🎯 Step 3: Build Output (dari belakang untuk stabil) + + Elemen 1: count[1] = 1 → output[1-1] = 1, count[1]-- + Elemen 3: count[3] = 5 → output[5-1] = 3, count[3]-- + Elemen 3: count[3] = 4 → output[4-1] = 3, count[3]-- + Elemen 8: count[8] = 7 → output[7-1] = 8, count[8]-- + Elemen 2: count[2] = 3 → output[3-1] = 2, count[2]-- + Elemen 2: count[2] = 2 → output[2-1] = 2, count[2]-- + Elemen 4: count[4] = 6 → output[6-1] = 4, count[4]-- + +Hasil akhir: [1, 2, 2, 3, 3, 4, 8] ✅ +``` + +#### Implementasi Kode + +```typescript +export const countingSort = ( + inputArr: number[], + min: number, + max: number +): number[] => { + const sortedArr: number[] = [] + + // Buat array count + const count = new Array(max - min + 1).fill(0) + + // Hitung frekuensi + for (const element of inputArr) { + count[element - min]++ + } + + // Hitung cumulative count + for (let i = 1; i < count.length; i++) { + count[i] += count[i - 1] + } + + // Build output array (dari belakang untuk stabilitas) + for (let i = inputArr.length - 1; i >= 0; i--) { + sortedArr[count[inputArr[i] - min] - 1] = inputArr[i] + count[inputArr[i] - min]-- + } + + return sortedArr +} +``` + +#### Visualisasi ASCII Art + +``` +Counting Sort Process: + +Input: [4, 2, 2, 8, 3, 3, 1] + +Step 1 - Count: +┌──────────────────────────────────────┐ +│ Value: 1 2 3 4 5 6 7 8│ +│ Count: 1 2 2 1 0 0 0 1│ +└──────────────────────────────────────┘ + +Step 2 - Cumulative: +┌──────────────────────────────────────┐ +│ Value: 1 2 3 4 5 6 7 8│ +│ Cumul: 1 3 5 6 6 6 6 7│ +└──────────────────────────────────────┘ + +Step 3 - Place elements: + 1 → pos 1 [1, _, _, _, _, _, _] + 2 → pos 3 [1, _, 2, _, _, _, _] + 2 → pos 2 [1, 2, 2, _, _, _, _] + 8 → pos 7 [1, 2, 2, _, _, _, 8] + 3 → pos 5 [1, 2, 2, _, 3, _, 8] + 3 → pos 4 [1, 2, 2, 3, 3, _, 8] + 4 → pos 6 [1, 2, 2, 3, 3, 4, 8] ✅ +``` + +#### Kapan Digunakan + +| ✅ Cocok Digunakan | ❌ Tidak Cocok | +|-------------------|----------------| +| Range nilai kecil (k << n) | Range nilai besar | +| Integer non-negatif | Data negatif (perlu modifikasi) | +| Butuh O(n) linear time | - | + +--- + +### Shell Sort + +#### Definisi +Shell Sort adalah optimasi dari Insertion Sort. Ia mengurutkan elemen yang **terpisah oleh gap/jarak tertentu**, lalu mengurangi gap secara bertahap sampai 1. + +#### Cara Kerja Step-by-Step + +``` +Array awal: [64, 34, 25, 12, 22, 11, 90] +n = 7 + +📏 Gap = n/2 = 3 + + Sub-array dengan gap 3: + [64, 34, 25, 12, 22, 11, 90] + ↑ ↑ ↑ + └───────────┘ │ → [64, 12, 90] → [12, 64, 90] + ↑ ↑ │ + └───────────┘ │ → [34, 22] → [22, 34] + ↑ ↑ │ + └───────────┘ │ → [25, 11] → [11, 25] + + Hasil: [12, 22, 11, 64, 34, 25, 90] + +📏 Gap = 3/2 = 1 + + Sekarang gap 1 (Insertion Sort biasa): + [12, 22, 11, 64, 34, 25, 90] + + Tapi sudah hampir terurut, jadi lebih cepat! + + [11, 12, 22, 25, 34, 64, 90] + +Hasil akhir: [11, 12, 22, 25, 34, 64, 90] ✅ +``` + +#### Implementasi Kode + +```typescript +export function shellSort(arr: T[]): T[] { + // Mulai dengan gap terbesar, kurangi setengah setiap iterasi + for (let gap = arr.length >> 1; gap > 0; gap >>= 1) { + + // Insertion sort untuk gap ini + for (let i = gap; i < arr.length; i++) { + const temp = arr[i] + let j = i + + // Geser elemen yang lebih besar + while (j >= gap && arr[j - gap] > temp) { + arr[j] = arr[j - gap] + j -= gap + } + + arr[j] = temp + } + } + return arr +} +``` + +#### Visualisasi ASCII Art + +``` +Shell Sort dengan Gap: + +Array: [64, 34, 25, 12, 22, 11, 90] + +Gap = 3: +64 ─────────── 12 ─────────── 90 → [12, 64, 90] + 34 ─────────── 22 → [22, 34] + 25 ─────────── 11 → [11, 25] + +Hasil: [12, 22, 11, 64, 34, 25, 90] + +Gap = 1 (Insertion Sort): +12 ← 22 ← 11 ← 64 ← 34 ← 25 ← 90 + ↓ +[11, 12, 22, 25, 34, 64, 90] ✅ +``` + +#### Kapan Digunakan + +| ✅ Cocok Digunakan | ❌ Tidak Cocok | +|-------------------|----------------| +| Array medium size | Butuh guarantee O(n log n) | +| In-place sorting | Data sangat besar | +| Lebih baik dari Insertion Sort | - | + +--- + +### Gnome Sort + +#### Definisi +Gnome Sort (Stupid Sort) adalah algoritma sederhana seperti **garden gnome** yang menyusun pot bunga. Jika pot bersebelahan sudah terurut, maju. Jika tidak, tukar dan mundur. + +#### Cara Kerja Step-by-Step + +``` +Array awal: [34, 2, 10, -9] + +🚶 Gnome berjalan: + +Posisi 0: [34, 2, 10, -9] + ↑ + 34 > 2? Ya, tukar dan mundur (tapi sudah di 0) + +Posisi 1: [2, 34, 10, -9] + ↑ + 34 > 10? Ya, tukar dan mundur ke 0 + +Posisi 0: [2, 10, 34, -9] + ↑ + 2 > 10? Tidak, maju + +Posisi 1: [2, 10, 34, -9] + ↑ + 10 > 34? Tidak, maju + +Posisi 2: [2, 10, 34, -9] + ↑ + 34 > -9? Ya, tukar dan mundur + +Posisi 1: [2, 10, -9, 34] + ↑ + 10 > -9? Ya, tukar dan mundur + +Posisi 0: [2, -9, 10, 34] + ↑ + 2 > -9? Ya, tukar dan mundur (tapi sudah di 0) + +Posisi 1: [-9, 2, 10, 34] + ↑ + -9 > 2? Tidak, maju terus sampai akhir... + +Hasil akhir: [-9, 2, 10, 34] ✅ +``` + +#### Implementasi Kode + +```typescript +export const gnomeSort = (arr: number[]): number[] => { + if (arr.length <= 1) return arr + + let i = 1 + + while (i < arr.length) { + if (arr[i - 1] <= arr[i]) { + // Sudah terurut, maju! + i++ + } else { + // Tidak terurut, tukar dan mundur + [arr[i], arr[i - 1]] = [arr[i - 1], arr[i]] + i = Math.max(1, i - 1) + } + } + return arr +} +``` + +#### Visualisasi ASCII Art + +``` +Gnome Sort - Si Kurcaci Penyusun: + +[34, 2, 10, -9] + 🚶 + + "Wah 34 > 2, tukar!" + [2, 34, 10, -9] + 🚶 + + "2 < 34, maju!" + [2, 34, 10, -9] + 🚶 + + "34 > 10, tukar!" + [2, 10, 34, -9] + 🚶 (mundur!) + + "2 < 10, maju!" + ... (lanjut sampai akhir) + + [-9, 2, 10, 34] ✅ + 🎉 +``` + +#### Kapan Digunakan + +| ✅ Cocok Digunakan | ❌ Tidak Cocok | +|-------------------|----------------| +| Data hampir terurut | Data besar | +| Implementasi sederhana | Performa penting | +| Belajar konsep | - | + +--- + +### Cycle Sort + +#### Definisi +Cycle Sort adalah algoritma **in-place** yang optimal untuk **minimalkan jumlah write**. Ia bekerja dengan mengidentifikasi "siklus" posisi yang benar untuk setiap elemen. + +#### Cara Kerja Step-by-Step + +``` +Array awal: [3, 1, 5, 4, 2] + +🔄 Cycle untuk elemen pertama (3): + + Posisi benar untuk 3 = count elemen < 3 = 2 (index 2) + + [3, 1, 5, 4, 2] + ↓___________↓ + 3 ke posisi 2 + + [5, 1, 3, 4, 2] ← 5 tertimpa, lanjutkan cycle! + + Posisi benar untuk 5 = 4 + [5, 1, 3, 4, 2] + ↓___________↓ + + [2, 1, 3, 4, 5] ← 2 tertimpa, lanjutkan! + + Posisi benar untuk 2 = 1 + [2, 1, 3, 4, 5] + ↓_____↓ + + [1, 2, 3, 4, 5] ← 1 tertimpa, lanjutkan! + + Posisi benar untuk 1 = 0 (sama dengan start), cycle selesai! + +Hasil akhir: [1, 2, 3, 4, 5] ✅ +``` + +#### Implementasi Kode + +```typescript +export const cycleSort = (array: number[]): number[] => { + for (let i = 0; i < array.length - 1; i++) { + moveCycle(array, i) + } + return array +} + +function moveCycle(array: number[], startIndex: number): void { + let currentItem = array[startIndex] + + // Hitung posisi yang benar + let nextChangeIndex = startIndex + countSmallerItems(array, startIndex, currentItem) + + if (nextChangeIndex === startIndex) return // Sudah di posisi benar + + // Lewati duplikat + nextChangeIndex = skipDuplicates(array, nextChangeIndex, currentItem) + + // Tukar dan lanjutkan cycle + let tmp = array[nextChangeIndex] + array[nextChangeIndex] = currentItem + currentItem = tmp + + while (nextChangeIndex !== startIndex) { + nextChangeIndex = startIndex + countSmallerItems(array, startIndex, currentItem) + nextChangeIndex = skipDuplicates(array, nextChangeIndex, currentItem) + + tmp = array[nextChangeIndex] + array[nextChangeIndex] = currentItem + currentItem = tmp + } +} + +function countSmallerItems(array: number[], startIndex: number, currentItem: number): number { + let count = 0 + for (let i = startIndex + 1; i < array.length; i++) { + if (currentItem > array[i]) count++ + } + return count +} +``` + +#### Visualisasi ASCII Art + +``` +Cycle Sort - Menemukan Siklus: + +[3, 1, 5, 4, 2] + ↓ + 3 harus di posisi 2 (ada 2 elemen < 3) + + [_, 1, 3, 4, 2] 3 ✓ + ↑ + 5 keluar, 5 harus di posisi 4 + + [_, 1, 3, 4, 5] 5 ✓ + ↑ + 2 keluar, 2 harus di posisi 1 + + [_, 2, 3, 4, 5] 2 ✓ + ↑ + 1 keluar, 1 harus di posisi 0 + + [1, 2, 3, 4, 5] 1 ✓ + ↑ + Cycle selesai! (kembali ke start) + + [1, 2, 3, 4, 5] ✅ +``` + +#### Kapan Digunakan + +| ✅ Cocok Digunakan | ❌ Tidak Cocok | +|-------------------|----------------| +| Minimalkan write operation | Data besar | +| Memory write mahal | Butuh speed | +| Embedded systems | - | + +--- + +### Bogo Sort + +#### Definisi +Bogo Sort (Stupid Sort / Monkey Sort) adalah algoritma yang **acak-acak array sampai kebetulan terurut**. Ini adalah algoritma terburuk yang pernah ada! 😅 + +#### Cara Kerja Step-by-Step + +``` +Array awal: [3, 2, 1] + +🎲 Shuffle 1: [2, 3, 1] → Cek: terurut? ❌ +🎲 Shuffle 2: [1, 2, 3] → Cek: terurut? ✅ SELESAI! + +Keberuntungan! Hanya 2 kali shuffle. + +--- + +Tapi bisa juga: +🎲 Shuffle 1: [3, 2, 1] → ❌ +🎲 Shuffle 2: [2, 1, 3] → ❌ +🎲 Shuffle 3: [1, 3, 2] → ❌ +🎲 Shuffle 4: [2, 3, 1] → ❌ +🎲 Shuffle 5: [3, 1, 2] → ❌ +... +🎲 Shuffle 1000000: ... +... +(Infiniti shuffle jika sial) +``` + +#### Implementasi Kode + +```typescript +import { isSortedArray } from '../other/is_sorted_array' +import { shuffleArray } from '../other/shuffle_array' + +export function bogoSort(arr: number[]): number[] { + while (!isSortedArray(arr)) { + shuffleArray(arr) // Acak terus sampai kebetulan terurut! + } + return arr +} +``` + +#### Visualisasi ASCII Art + +``` +Bogo Sort - Algoritma "Harapan dan Doa": + +[3, 1, 2] 🎲 + ↓ shuffle +[1, 3, 2] ❌ Belum terurut! + ↓ shuffle +[2, 1, 3] ❌ Belum terurut! + ↓ shuffle +[3, 2, 1] ❌ Belum terurut! + ↓ shuffle +[1, 2, 3] ✅ AKHIRNYA! 🎉 + +Kompleksitas: O(?) = Keberuntungan! 🍀 +``` + +#### Kapan Digunakan + +| ✅ Cocok Digunakan | ❌ Tidak Cocok | +|-------------------|----------------| +| Lelucon/teka-teki | Produksi/serius | +| Menguji kesabaran | Data > 10 elemen | +| Memahami pentingnya algoritma | - | + +--- + +### Tree Sort + +#### Definisi +Tree Sort membangun **Binary Search Tree (BST)** dari elemen array, lalu melakukan **in-order traversal** untuk mendapatkan elemen terurut. + +#### Cara Kerja Step-by-Step + +``` +Array awal: [5, 3, 8, 1, 4, 7, 9] + +🌳 Step 1: Build BST + + Insert 5: 5 + + Insert 3: 5 + / + 3 + + Insert 8: 5 + / \ + 3 8 + + Insert 1: 5 + / \ + 3 8 + / + 1 + + Insert 4: 5 + / \ + 3 8 + / \ + 1 4 + + Insert 7, 9: 5 + / \ + 3 8 + / \ /\ + 1 4 7 9 + +🚶 Step 2: In-order Traversal (Kiri → Root → Kanan) + + 1 → 3 → 4 → 5 → 7 → 8 → 9 + +Hasil akhir: [1, 3, 4, 5, 7, 8, 9] ✅ +``` + +#### Implementasi Kode + +```typescript +import { BinarySearchTree } from '../data_structures/tree/binary_search_tree' + +export const treeSort = (arr: T[]): T[] => { + // Bangun BST dari array + const searchTree = new BinarySearchTree() + for (const item of arr) { + searchTree.insert(item) + } + + // In-order traversal memberikan hasil terurut + return searchTree.inOrderTraversal() +} +``` + +#### Visualisasi ASCII Art + +``` +Tree Sort - Dari Array ke BST: + +Array: [5, 3, 8, 1, 4, 7, 9] + + 5 ← Root + / \ + 3 8 ← Level 1 + / \ /\ + 1 4 7 9 ← Level 2 + +In-order Traversal: + ↓ + 1 (kiri 3) + ↓ + 3 (root subtree kiri) + ↓ + 4 (kanan 3) + ↓ + 5 (root utama) + ↓ + 7 (kiri 8) + ↓ + 8 (root subtree kanan) + ↓ + 9 (kanan 8) + +Hasil: [1, 3, 4, 5, 7, 8, 9] ✅ +``` + +#### Kapan Digunakan + +| ✅ Cocok Digunakan | ❌ Tidak Cocok | +|-------------------|----------------| +| Data masuk streaming | Data sudah ada di memory | +| Butuh struktur tree | Butuh O(n) space | +| Frequent insertions | Data terurut (tree jadi skewed) | + +--- + +### Quick Select + +#### Definisi +Quick Select adalah algoritma untuk **menemukan elemen ke-k terkecil** tanpa mengurutkan seluruh array. Ini adalah variasi dari Quick Sort. + +#### Cara Kerja Step-by-Step + +``` +Array: [3, 2, 1, 5, 4], cari elemen ke-3 terkecil (index 2) + +🔀 Step 1: Partition dengan pivot + + Pilih pivot = 4 (terakhir) + [3, 2, 1, 5, 4] + ↓ + [3, 2, 1] 4 [5] + <4 pivot >4 + + Pivot index = 3 + +🎯 Step 2: Bandingkan dengan k + + k = 2, pivot index = 3 + + k < pivot index? Ya (2 < 3) + → Cari di kiri: [3, 2, 1] + +🔀 Step 3: Partition lagi + + Pilih pivot = 1 + [3, 2, 1] + ↓ + [] 1 [3, 2] + pivot + + Pivot index = 0 (dalam sub-array) + = 0 dalam array asli + +🎯 Step 4: Bandingkan lagi + + k = 2, pivot index = 0 + + k > pivot index? Ya (2 > 0) + → Cari di kanan: [3, 2] + → Adjust k: k = 2 - 0 - 1 = 1 + +🔀 Step 5: Partition lagi + + Pilih pivot = 2 + [3, 2] + ↓ + [] 2 [3] + + Pivot index = 1 (dalam sub-array) + = 0 + 1 + 1 = 2 dalam array asli + +🎯 Step 6: Ketemu! + + k = 1, pivot index = 1 + k === pivot index? Ya! + + Return array[2] = 3 + +Jawaban: Elemen ke-3 terkecil adalah 3 ✅ +``` + +#### Implementasi Kode + +```typescript +import { partition } from './quick_sort' + +export const QuickSelect = ( + array: number[], + k: number, + left: number = 0, + right: number = array.length - 1 +): number => { + if (k < 0 || k >= array.length) { + throw new Error('k is out of bounds') + } + + if (left === right) { + return array[left] + } + + // Partition array + const pivotIndex = partition(array, left, right) + + // Pivot sudah di posisi final + if (k === pivotIndex) { + return array[k] + } else if (k < pivotIndex) { + // Cari di bagian kiri + return QuickSelect(array, k, left, pivotIndex - 1) + } else { + // Cari di bagian kanan + return QuickSelect(array, k, pivotIndex + 1, right) + } +} +``` + +#### Visualisasi ASCII Art + +``` +Quick Select - Cari ke-3 terkecil: + +[3, 2, 1, 5, 4] k=2 + ↑ + pivot=4 (idx=3) + +[3, 2, 1] 4 [5] + ↑ + k=2 < 3, cari di kiri! + +[3, 2, 1] + ↑ + pivot=1 (idx=0) + +[] 1 [3, 2] + ↑ + k=2 > 0, cari di kanan! + k baru = 2-0-1 = 1 + +[3, 2] + ↑ + pivot=2 (idx=1) + +[] 2 [3] + ↑ + k=1 === idx=1 ✓ + +Return: 3 ✅ +``` + +#### Kapan Digunakan + +| ✅ Cocok Digunakan | ❌ Tidak Cocok | +|-------------------|----------------| +| Cari median | Butuh semua elemen terurut | +| Cari top-k elements | k sangat kecil (better use heap) | +| Array besar, hanya butuh 1 elemen | - | + +--- + +### Swap Sort + +#### Definisi +Swap Sort (Minimum Swaps to Sort) menghitung **jumlah minimum swap** yang diperlukan untuk mengurutkan array. Ini adalah algoritma utility, bukan sorting algorithm. + +#### Cara Kerja Step-by-Step + +``` +Array awal: [4, 3, 2, 1] +Array target (sorted): [1, 2, 3, 4] + +🗺️ Step 1: Buat mapping posisi + + Elemen: 4 3 2 1 + Index: 0 1 2 3 + + Posisi benar: + 1 harus di index 0 (sekarang di index 3) + 2 harus di index 1 (sekarang di index 2) + 3 harus di index 2 (sekarang di index 1) + 4 harus di index 3 (sekarang di index 0) + +🔄 Step 2: Lakukan swap + + Index 0: 4 ≠ 1? Ya, tukar 4 dengan elemen yang punya 1 + [1, 3, 2, 4], swaps = 1 + + Index 1: 3 ≠ 2? Ya, tukar 3 dengan elemen yang punya 2 + [1, 2, 3, 4], swaps = 2 + + Index 2: 3 === 3? Sudah benar + Index 3: 4 === 4? Sudah benar + +Total swaps: 2 ✅ +``` + +#### Implementasi Kode + +```typescript +export const minSwapsToSort = (inputArr: number[]): number => { + // Copy dan sort untuk dapat target + const sortedArray = inputArr.slice() + sortedArray.sort() + + // Mapping: nilai → index asli + const indexMap = new Map() + for (let i = 0; i < inputArr.length; i++) { + indexMap.set(inputArr[i], i) + } + + let swaps = 0 + for (let i = 0; i < inputArr.length; i++) { + if (inputArr[i] !== sortedArray[i]) { + // Tukar elemen saat ini dengan elemen yang seharusnya ada di sini + const temp = inputArr[i] + const targetIndex = indexMap.get(sortedArray[i])! + + inputArr[i] = inputArr[targetIndex] + inputArr[targetIndex] = temp + + // Update mapping + indexMap.set(temp, targetIndex) + indexMap.set(sortedArray[i], i) + + swaps++ + } + } + + return swaps +} +``` + +#### Visualisasi ASCII Art + +``` +Minimum Swaps to Sort: + +Array: [4, 3, 2, 1] +Target: [1, 2, 3, 4] + +Cycle 1: + 4 di posisi 0, tapi 1 yang harus di sana + 1 ada di posisi 3 + Tukar! [1, 3, 2, 4] + +Cycle 2: + 3 di posisi 1, tapi 2 yang harus di sana + 2 ada di posisi 2 + Tukar! [1, 2, 3, 4] + +Total: 2 swaps ✅ +``` + +#### Kapan Digunakan + +| ✅ Cocok Digunakan | ❌ Tidak Cocok | +|-------------------|----------------| +| Analisis efisiensi sorting | Sorting sebenarnya | +| Optimasi jumlah operasi | - | +| Problem solving (competitive programming) | - | + +--- + +## 4. Resume Bahasa Bayi + +### 🍼 Analogi Sederhana + +``` +┌─────────────────────────────────────────────────────────────┐ +│ SORTING UNTUK ANAK KECIL │ +├─────────────────────────────────────────────────────────────┤ +│ │ +│ 🫧 Bubble Sort │ +│ "Bandingkan dua-dua, yang besar geser ke kanan │ +│ seperti gelembung naik ke permukaan!" │ +│ │ +│ 🎯 Selection Sort │ +│ "Cari yang paling kecil, taruh di depan. │ +│ Ulangi sampai semua terurut!" │ +│ │ +│ 🃏 Insertion Sort │ +│ "Kayak susun kartu di tangan, │ +│ masukin satu-satu ke tempat yang pas!" │ +│ │ +│ 🍰 Merge Sort │ +│ "Potong kue jadi dua, urutin masing-masing, │ +│ lalu gabungin lagi!" │ +│ │ +│ ⚡ Quick Sort │ +│ "Pilih pemimpin (pivot), yang kecil di kiri, │ +│ yang besar di kanan, ulangi!" │ +│ │ +│ 🏔️ Heap Sort │ +│ "Bangun gunung (max heap), ambil puncaknya, │ +│ ulangi sampai habis!" │ +│ │ +│ 🔢 Counting Sort │ +│ "Hitung ada berapa 1, berapa 2, dst... │ +│ lalu tulis ulang sesuai hitungan!" │ +│ │ +│ 📏 Shell Sort │ +│ "Insertion sort tapi loncat-loncat dulu, │ +│ biar lebih cepat!" │ +│ │ +│ 🧙 Gnome Sort │ +│ "Jalan maju, kalau ketemu yang salah tukar │ +│ dan mundur, kayak kurcaci!" │ +│ │ +│ 🎲 Bogo Sort │ +│ "Kocak-kocak sampai kebetulan bener, │ +│ jangan dipake serius ya!" │ +│ │ +└─────────────────────────────────────────────────────────────┘ +``` + +### 🎯 Cheat Sheet Pilih Algoritma + +``` +┌─────────────────────────────────────────────────────────────┐ +│ PANDUAN MEMILIH SORTING │ +├─────────────────────────────────────────────────────────────┤ +│ │ +│ 💾 MEMORI TERBATAS? │ +│ → Heap Sort, Quick Sort, Shell Sort │ +│ │ +│ ⚡ BUTUH CEPAT (DATA BESAR)? │ +│ → Quick Sort, Merge Sort, Heap Sort │ +│ │ +│ 🔄 DATA SUDAH HAMPIR TERURUT? │ +│ → Insertion Sort, Bubble Sort, Gnome Sort │ +│ │ +│ 🔢 DATA INTEGER DENGAN RANGE KECIL? │ +│ → Counting Sort │ +│ │ +│ 📊 BUTUH STABIL (ELEMEN SAMA TETAP URUT)? │ +│ → Merge Sort, Insertion Sort, Counting Sort │ +│ │ +│ 🎓 LAGI BELAJAR? │ +│ → Bubble Sort, Selection Sort, Insertion Sort │ +│ │ +│ 😈 MAU NGERJAIN TEMAN? │ +│ → Bogo Sort │ +│ │ +└─────────────────────────────────────────────────────────────┘ +``` + +### 📈 Kompleksitas dalam Satu Kalimat + +| Notasi | Artinya | Contoh | +|--------|---------|--------| +| **O(1)** | Konstan | Akses array by index | +| **O(n)** | Linear | Loop sekali through array | +| **O(n log n)** | Linearitmik | Merge Sort, Quick Sort (bagus!) | +| **O(n²)** | Kuadratik | Bubble, Selection, Insertion (hati-hati!) | +| **O(n!)** | Faktorial | Bogo Sort (jangan!) | + +### 🎓 Tips Belajar + +1. **Mulai dari yang sederhana**: Pahami Bubble Sort dulu +2. **Visualisasi**: Gambar prosesnya di kertas +3. **Coding**: Implementasi sendiri, jangan copy-paste +4. **Bandingkan**: Pahami kapan pakai yang mana +5. **Latihan**: LeetCode, HackerRank, dll. + +--- + +## 📚 Referensi + +- [Bubble Sort - FreeCodeCamp](https://www.freecodecamp.org/news/bubble-sort) +- [Merge Sort - Javatpoint](https://www.javatpoint.com/merge-sort) +- [Quick Sort - Javatpoint](https://www.javatpoint.com/quick-sort) +- [Heap Sort - GeeksforGeeks](https://www.geeksforgeeks.org/heap-sort/) +- [Counting Sort - Wikipedia](https://en.wikipedia.org/wiki/Counting_sort) +- [Shell Sort - GeeksforGeeks](https://www.geeksforgeeks.org/shellsort/) +- [Gnome Sort - Wikipedia](https://en.wikipedia.org/wiki/Gnome_sort) +- [Cycle Sort - Wikipedia](https://en.wikipedia.org/wiki/Cycle_sort) +- [Bogo Sort - Wikipedia](https://en.wikipedia.org/wiki/Bogosort) +- [Tree Sort - Wikipedia](https://en.wikipedia.org/wiki/Tree_sort) + +--- + +> 💡 **Pro Tip**: Tidak ada algoritma sorting yang "terbaik" untuk semua kasus. Pilih berdasarkan kebutuhan spesifik kamu! + +--- + +*Dokumentasi ini dibuat untuk membantu pemula memahami algoritma sorting dengan mudah. Selamat belajar! 🚀*