ดูโค้ดวิ่งทีละบรรทัด แล้วจะเข้าใจโครงสร้างข้อมูลเอง

1 · ใส่ข้อมูลหรือกดปุ่มคำสั่ง

หัวข้อเรียงข้อมูลให้พิมพ์ตัวเลขเอง หรือกด "สุ่ม" · หัวข้อโครงสร้างข้อมูล (list, tree, hash) มีปุ่มคำสั่ง เช่น insert(e) delete(e) กดต่อกันได้เรื่อย ๆ

2 · ไล่ทีละขั้น

กด ถัดไป ▶ / ◀ ก่อนหน้า หรือ ⏵ เล่น ให้วิ่งเอง ลากแถบเลื่อนไปขั้นไหนก็ได้ · คลิกในกล่องแล้วใช้ปุ่ม ← → และ Space ได้

3 · ดูให้ครบ 4 จุด

• บรรทัดสีส้ม ▶ = บรรทัดที่กำลังทำ
• บล็อกสี = โค้ดส่วนนั้นทำหน้าที่อะไร
• ป้ายตัวแปร กล่องที่เปลี่ยนสีคือค่าที่เพิ่งเปลี่ยน
• 💬 = อธิบายว่าเกิดอะไรขึ้นและทำไม

4 · ทบทวนท้ายเล่ม

มีตาราง Big-O รวมพร้อมกราฟ, Flashcards และข้อสอบปรนัย 50 ข้อ (ทำไปอ่านไปได้ คำตอบถูกบันทึกไว้)

ขั้นตอน

1. เริ่มที่ตัวที่ 2 (i = 1) เพราะตัวแรกตัวเดียวถือว่าเรียงแล้ว
2. หยิบ list[i] ขึ้นมาถือไว้ (currentElement)
3. ตัวทางซ้ายที่ใหญ่กว่า ให้เลื่อนไปขวาทีละช่อง แล้ววางตัวที่ถือลงช่องที่ว่าง

ขั้นตอน

1. รอบที่ k: เทียบ list[i] กับ list[i+1] ตั้งแต่ i = 0 ถึง n−k−1
2. ถ้า list[i] > list[i+1] สลับกัน และจดไว้ว่า needNextPass = true
3. ถ้าทั้งรอบไม่มีการสลับเลย แปลว่าเรียงแล้ว หยุดได้ทันที

ขั้นตอน

1. ถ้ามีมากกว่า 1 ตัว: ก๊อปครึ่งแรกเป็น firstHalf ครึ่งหลังเป็น secondHalf
2. เรียก mergeSort กับแต่ละครึ่ง (recursion — method เรียกตัวเอง)
3. merge: เทียบหัวแถวสองฝั่ง หยิบตัวที่น้อยกว่าไปก่อน ฝั่งไหนเหลือก็ต่อท้าย

partition ทำงานยังไง

1. pivot = ตัวแรก · low เดินจากซ้าย หยุดที่ตัวที่ มากกว่า pivot
2. high เดินจากขวา หยุดที่ตัวที่ ไม่มากกว่า pivot · ถ้ายังไม่สวนกันก็สลับสองตัวนั้น
3. สวนกันแล้ว วาง pivot ลงที่ high แล้วคืนตำแหน่งนั้น

เก็บใน ArrayList ได้เลย

ไม่ต้องมีลูกศร เพราะคำนวณตำแหน่งได้:

• ลูกซ้ายของช่อง i = 2i + 1
• ลูกขวาของช่อง i = 2i + 2
• พ่อของช่อง i = (i − 1) / 2

2 งานหลัก

• add: ต่อท้าย แล้ว "ลอยขึ้น" สลับกับพ่อจนถูกกฎ
• remove: เอา root ออก เอาตัวท้ายขึ้นแทน แล้ว "จมลง" สลับกับลูกตัวที่ใหญ่กว่า
• ทั้งคู่ O(log n) = ความสูงต้นไม้

Bucket sort

key อยู่ในช่วง 0..t → เตรียมถัง t+1 ใบ ใส่ตัวที่ key = i ลงถัง i แล้วเก็บจากถัง 0 ถึง t · ใช้เวลา O(n + t) แต่ถ้า t ใหญ่มาก (เช่น 0..1,000,000) เปลืองถังเกินไป

Radix sort

ใช้ถังแค่ 10 ใบ (0–9) แต่ทำหลายรอบ ทีละหลัก เริ่มจากหลักหน่วย · ถังต้องเป็นแบบ stable (มาก่อนอยู่ก่อน) ลำดับจากรอบก่อนจึงไม่เสีย · O(dn)

2 phase

1. Phase I: อ่านเข้า array ทีละก้อน (MAX_ARRAY_SIZE) → เรียงในหน่วยความจำ → เขียนลง f1.dat เป็นก้อน S1, S2, …
2. Phase II: ย้ายครึ่งแรกของก้อนไป f2.dat แล้ว merge ก้อนคู่กัน (S1 กับ S(k/2+1), …) ลง f3.dat
3. ก้อนใหญ่ขึ้นเท่าตัวทุกรอบ ทำซ้ำจนเหลือก้อนเดียว

MyList<E> (interface)

สัญญาว่า list ทุกแบบต้องมี: add(index, e) get set remove(index) indexOf lastIndexOf และมี default method เช่น add(e) = ใส่ที่ index size()

ข้างใน MyArrayList

• E[] data — array เก็บของ
• size — มีของกี่ตัว
• data.length — ความจุ (capacity) ≥ size
• array ขยายตัวเองไม่ได้ → ต้องสร้างใหม่ใหญ่กว่าแล้วก๊อป

กฎทองของการต่อสาย

1. ต่อสายใหม่ "ก่อน" ตัดสายเดิมเสมอ ไม่งั้นส่วนที่เหลือของขบวนหายไป
2. อย่าลืมกรณีพิเศษ: list ว่าง (head = tail = null) และมีตัวเดียว
3. ทุกครั้งที่แก้ head/tail ต้องเช็คว่าอีกตัวยังถูกอยู่ไหม

MyPriorityQueue = ห่อ Heap

• enqueue(e) → heap.add(e) ตัวที่สำคัญลอยขึ้นบน
• dequeue() → heap.remove() เอา root (สำคัญสุด) ออก
• ทั้งคู่ O(log n) · Patient ต้อง implements Comparable เพื่อเทียบ priority

คำศัพท์ของต้นไม้

depth ของโหนด = จำนวนเส้นจาก root ลงมาถึงมัน (60 → 0, 45 → 2) · height ของต้นไม้ = ทางยาวสุดจาก root ถึงใบ (ต้นนี้ = 2) · ต้นไม้ย่อย (subtree) = โหนดหนึ่งพร้อมลูกหลานทั้งหมด

inorder

ซ้าย → ตัวเอง → ขวา
ได้ค่าเรียงน้อยไปมาก

45 55 57 60 67 100 107

preorder

ตัวเอง → ซ้าย → ขวา
= depth-first

60 55 45 57 100 67 107

postorder

ซ้าย → ขวา → ตัวเอง
ลูกก่อนพ่อเสมอ

45 57 55 67 107 100 60

breadth-first

ทีละชั้น บน→ล่าง ซ้าย→ขวา ใช้ queue

60 55 100 45 57 67 107

Iterator (25.5)

วัตถุที่ให้ "ไล่ทีละตัว" แบบเดียวกันทุกโครงสร้าง: hasNext() ยังมีตัวถัดไปไหม · next() คืนตัวถัดไป · BST ใน Java ใช้ for (E e : tree) ได้เพราะ implements Iterable

InorderIterator ในหนังสือทำง่าย ๆ: เรียก inorder เก็บใส่ ArrayList ไว้ก่อน แล้วค่อยหยิบทีละตัว · ลองกด iterator.next() ด้านบนหลายครั้ง

Tree visualization + MVC (25.4)

โปรแกรมแสดงต้นไม้ (BSTAnimation) แยกเป็น 3 ส่วน:

• Model = BST (ข้อมูล)
• View = BTView วาดต้นไม้ (วาดซ้ำแบบ recursion: วาดโหนด แล้ววาดต้นไม้ย่อยซ้าย/ขวา)
• Controller = ปุ่ม Insert/Delete ที่รับคำสั่งแล้วสั่ง model และให้ view วาดใหม่

กรณี 1: ไม่มีลูกซ้าย

ให้พ่อ (parent) ชี้ไปที่ลูกขวาของ current แทน แล้ว current ก็หลุดไปเอง · ถ้า current เป็นใบ ลูกขวาคือ null ก็จบ · ถ้า current เป็น root ให้ root = current.right

กรณี 2: มีลูกซ้าย

หา rightMost = ตัวขวาสุดในต้นไม้ย่อยซ้าย (ตัวใหญ่สุดที่ยังน้อยกว่า current) → ก๊อปค่ามาใส่ current → ตัด rightMost ทิ้งโดยต่อ rightMost.left ให้พ่อของมัน · rightMost ไม่มีลูกขวาแน่นอน แต่อาจมีลูกซ้าย

สร้างต้นไม้ (greedy)

1. นับความถี่ แต่ละตัวอักษรเป็นต้นไม้ 1 โหนด น้ำหนัก = ความถี่
2. หยิบ 2 ต้นที่เบาที่สุด รวมเป็นต้นใหม่ (น้ำหนักบวกกัน) ทำซ้ำจนเหลือต้นเดียว
3. เดินจาก root: ซ้าย = 0 ขวา = 1 ถึงใบก็ได้รหัสของตัวนั้น

Balance factor (bf)

bf = ความสูงขวา − ความสูงซ้าย

• ใบ (leaf) สูง 0 · ต้นไม้ว่าง (null) สูง −1
• bf = −1, 0, +1 → สมดุล
• bf ≤ −1 = เอียงซ้าย (left-heavy) · ≥ +1 = เอียงขวา
• bf = −2 หรือ +2 → ต้องหมุน

เลือกการหมุน

LL → หมุนขวาครั้งเดียว (RR คือกลับด้าน)

B ขึ้นเป็นพ่อ · A ลงไปเป็นลูกขวาของ B · T2 ย้ายข้างจากลูกขวาของ B ไปเป็นลูกซ้ายของ A (ค่าใน T2 อยู่ระหว่าง B กับ A พอดี)

LR → หมุนสองต่อ ให้ C ขึ้นเป็นพ่อ (RL คือกลับด้าน)

ทางเอียงหักมุม (ซ้ายแล้วขวา) หมุนครั้งเดียวไม่หาย → C ซึ่งอยู่ระหว่าง B กับ A ขึ้นเป็นพ่อของทั้งคู่ · T2 ไปเป็นลูกขวาของ B · T3 ไปเป็นลูกซ้ายของ A

AVLTreeNode

สืบทอดจาก TreeNode แล้วเพิ่มฟิลด์ height เพื่อคำนวณ bf ได้เร็วโดยไม่ต้องนับใหม่ทั้งต้นไม้ · override createNewNode ให้สร้าง AVLTreeNode

balancePath(e)

1. ขอ path จาก root ถึงโหนด e
2. ไล่จากล่างขึ้นบน: updateHeight แล้วดู bf
3. bf = ±2 → หมุนแบบที่ตรงกรณี

ทำไมเร็ว

ความสูง AVL ≤ ประมาณ 1.44 log(n+2) → O(log n) · การหมุนแต่ละครั้งแก้ลูกศรไม่กี่เส้น O(1) · insert, delete, search จึงเป็น O(log n) ทั้งหมด

Linear probing

ลอง k, k+1, k+2, … (ทีละ 1)

ข้อเสีย: clustering ของจับกลุ่มเป็นก้อนยาว ยิ่งก้อนใหญ่ยิ่งชนบ่อย ค้นหาช้า · ข้อดี: ถ้าตารางไม่เต็ม เจอที่ว่างแน่นอน

Quadratic probing

ลอง k, k+1², k+2², k+3², … (k+1, k+4, k+9)

แก้ clustering แบบติดกันได้ แต่ยังมี secondary clustering (key ที่เริ่มช่องเดียวกันไปทางเดียวกัน) และไม่รับประกันว่าจะเจอช่องว่าง

Double hashing

ลอง k, k+h'(key), k+2h'(key), … เช่น h'(key) = 7 − key % 7

ระยะกระโดดขึ้นกับ key แต่ละตัว กระจายดีที่สุดในสามแบบ · h'(key) ห้ามเป็น 0

Load factor λ = n / N

n = จำนวนข้อมูล · N = ขนาดตาราง · λ สูง = แน่น ชนบ่อย

• open addressing ควร λ < 0.5
• separate chaining ควร λ < 0.9
• java.util.HashMap ใช้เกณฑ์ 0.75

Rehashing

เกินเกณฑ์ → สร้างตารางใหม่ใหญ่ขึ้น (อย่างน้อย 2 เท่า) แล้ว put ทุกตัวใหม่ เพราะ index ขึ้นกับขนาดตาราง · ช้า O(capacity) แต่เกิดนาน ๆ ครั้ง put โดยเฉลี่ยจึงยัง O(1)

ข้างใน MyHashMap

• LinkedList<MyMap.Entry<K,V>>[] table — ตาราง ช่องละหนึ่งถัง
• capacity เป็นกำลังของ 2 เสมอ (เริ่ม 4 · trimToPowerOf2 ปัดให้เป็น 2^k) สูงสุด 1 << 30
• loadFactorThreshold ค่าเริ่ม 0.75f
• hash(h) = supplementalHash(h) & (capacity − 1)
• เงื่อนไข rehash ใน put: size >= capacity * loadFactorThreshold

MyHashSet

แนวเดียวกับ MyHashMap แต่เก็บแค่ key (ไม่มี value) ใช้ทำ set ที่ไม่มีค่าซ้ำ: add เช็คก่อนว่ามีอยู่แล้วหรือไม่ · contains / add / remove เฉลี่ย O(1)