1. LINKED LIST (SINGLY & DOUBLY) — WEEK 8

1. Konsep & Class Node

• Singly: Data + Next.
• Doubly: Data + Next (Maju) + Prev (Mundur).

public class Node {
    public int Data;
    public Node Next;
    public Node Prev; // Khusus Doubly
}

2. Rumus Coding (Hafalan Wajib)

Insert Front (Depan):

baru.Next = Head;
if (Head != null) Head.Prev = baru;
Head = baru;

Insert Back (Belakang):

Node h = Head;
while (h.Next != null) h = h.Next; // Loop ke ujung
h.Next = baru;
baru.Prev = h; // Sambung balik

Insert Order (Ascending) — PENTING!

if (Head == null || Head.Data >= baru.Data) 
    InsertFront(baru);
else {
   Node h = Head;
   // Cari posisi: berhenti jika Next > baru
   while (h.Next != null && h.Next.Data < baru.Data) 
       h = h.Next;
   // Sisipkan
   baru.Next = h.Next;
   h.Next = baru;
}

Delete Front: Head = Head.Next; (Doubly: if(Head!=null) Head.Prev = null;)

Delete Back: Loop sampai h.Next.Next == null, lalu h.Next = null;

3. Visualisasi Pointer

Soal: Head.Next.Next.Next.Prev = Head.Next;
Analisa: Ubah Prev milik Sate (Node 4) ke Siomay (Node 2).

Hasil: List rusak. Pointer Next Kwetiau ke Sate, tapi Prev Sate ke Siomay.

2. BINARY SEARCH TREE (BST) — WEEK 10

1. Logika & Traversal

• Aturan: Kecil &to; Kiri, Besar &to; Kanan.
• PreOrder: Root &to; Kiri &to; Kanan.
• InOrder: Kiri &to; Root &to; Kanan (Pasti Urut).
• PostOrder: Kiri &to; Kanan &to; Root.

2. Hapus Node (Deletion Logic)

• Leaf: Hapus langsung.
• 1 Anak: Parent bypass ke Cucu.
• 2 Anak: Ganti nilai dengan Successor (Min Kanan) atau Predecessor (Max Kiri), lalu hapus node aslinya.

3. Contoh Soal: Delete 2 Anak

Soal: Hapus Node 175 (Punya anak 90 & 200).

• Step 1: Cari Successor (Terkecil di kanan). Successor = 200.
• Step 2: Ganti nilai 175 jadi 200.
• Step 3: Hapus node 200 yang lama.

3. AVL TREE (BALANCING) — WEEK 12

1. Rumus Penting

• Height: 1 + Max(Kiri, Kanan). (Leaf=1).
• Balance Factor (BF): Kanan - Kiri.
• Unbalanced: Jika BF ≤ -2 atau ≥ +2.

2. Tabel Rotasi (+ Kanan, - Kiri)

3. Visualisasi Rotasi (Insert 46, 83, 87)

Analisa: 46 (BF=+2), 83 (BF=+1). Case Right-Right (+,+). Solusi: Single Left pada 46.

4. SORTING ALGORITHMS — WEEK 13

1. Simple Sorts (O(n²))

Bubble Sort (Descending): Cek tetangga. Jika Kiri < Kanan, TUKAR.

Selection Sort: Cari Max/Min, tukar ke depan.

Insertion Sort: Ambil, selipkan ke posisi pas.

while (j>0 && arr[j-1] >= temp) { 
    arr[j] = arr[j-1]; j--; 
}

2. Advanced Sorts (O(n log n))

• Merge Sort: Divide & Conquer.
• Quick Sort: Pakai Pivot.
• Heap Sort (Langkah):
  1. Build Max-Heap (Parent > Child).
  2. Swap Root (Terbesar) dengan elemen terakhir.
  3. Heapify (Perbaiki heap).
  4. Ulangi langkah 2-3.

3. Radix Sort (O(nk))

Urutkan: 170, 45, 802 (Ascending)

1. Satuan: 170, 802, 45 &to; 170, 802, 45.
2. Puluhan: 802, 45, 170 &to; 802, 45, 170.
3. Ratusan: 045, 170, 802 &to; 45, 170, 802.

5. CATATAN AKHIR (RINGKASAN CEPAT)

• BST InOrder = Hasil pasti urut.
• AVL (+,+) = Single Left Rotation.
• AVL (-,-) = Single Right Rotation.
• Bubble = Tukar tetangga.
• Selection = Cari Juara (lempar ke depan).

E. AVL TREE CASES (WEEK 13 & 12) + TREE VISUAL

F. WEEK 14 PRACTICE & REKURSIF