Iteration & Recursion

Iteration คืออะไร

Iteration (การทำซ้ำ) คือเทคนิคการเขียนโปรแกรมที่ให้โค้ดทำงานเดิมซ้ำหลายรอบผ่านโครงสร้างลูป เช่น for, while, do...while โดยใช้ตัวแปรเดิมอัปเดตสถานะไปทีละรอบจนกว่าเงื่อนไขหยุดจะเป็นจริง

ภาพจำง่าย: เดินทีละก้าวบนทางราบ ทุกก้าวอยู่ในฟังก์ชันเดิม ไม่มีการเรียกฟังก์ชันชั้นใหม่ ไม่มีการซ้อน call stack

• ทำงานซ้ำใน scope เดิม — ไม่เปลือง call stack
• ใช้ตัวแปรควบคุม (i, result, sum) อัปเดตทีละรอบ
• จบเมื่อเงื่อนไขเป็นเท็จ — ควบคุมง่าย ดีบั๊กตรงไปตรงมา

โครงสร้างของลูปใน JavaScript

JavaScript มีโครงสร้างลูปหลัก 3 แบบ — แต่ละแบบเหมาะกับสถานการณ์ต่างกัน มาดูรูปแบบและจุดเด่นของแต่ละแบบ

// 1. for loop — รู้จำนวนรอบแน่นอน
for (let i = 0; i < 5; i += 1) {
  console.log("รอบที่", i + 1);
}

// 2. while loop — วนตราบใดที่เงื่อนไขเป็นจริง
let count = 0;
while (count < 3) {
  console.log("count:", count);
  count += 1;
}

// 3. do...while loop — รับประกันอย่างน้อย 1 รอบ
let attempt = 0;
do {
  console.log("attempt:", attempt);
  attempt += 1;
} while (attempt < 2);

ไม่ว่าลูปแบบไหน หัวใจสำคัญคือ 3 ส่วน: (1) จุดเริ่มต้น (2) เงื่อนไขหยุด (3) การอัปเดตค่าทีละรอบ — ถ้าขาดอย่างใดอย่างหนึ่ง ลูปอาจทำงานผิดหรือไม่จบ

ตัวอย่าง: factorial แบบ Iteration

โจทย์ factorial (n!) เหมาะมากสำหรับทำความเข้าใจ iteration — เราคูณสะสมผลลัพธ์เข้าไปในตัวแปร result ทีละรอบจนถึง n

function factorialIteration(n) {
  if (n < 0) {
    throw new Error("n ต้องมากกว่าหรือเท่ากับ 0");
  }

  let result = 1;

  for (let i = 2; i <= n; i += 1) {
    result *= i;
  }

  return result;
}

console.log(factorialIteration(5)); // 120

อธิบายทีละส่วน: • `let result = 1` — ตัวสะสมผลลัพธ์เริ่มต้นที่ 1 (เพราะการคูณต้องเริ่มจาก 1 ไม่ใช่ 0) • `for (let i = 2; i <= n; i += 1)` — เริ่ม i=2 (ข้าม 1 เพราะคูณ 1 ไม่เปลี่ยนค่า) วนจนถึง n • `result *= i` — คูณค่าสะสมด้วย i ในแต่ละรอบ • ถ้า `n = 0` หรือ `n = 1` → for loop ไม่รัน → return 1 (ถูกต้องตามนิยาม 0! = 1! = 1)

State เปลี่ยนทีละรอบอย่างไร

เวลามอง iteration ให้ดูว่าแต่ละรอบตัวแปรสำคัญเปลี่ยนจากค่าเดิมเป็นค่าใหม่อย่างไร — เรียกแนวนี้ว่า state transition หรือการเปลี่ยนสถานะทีละรอบ

• รอบที่ 1: i = 2, result = 1 × 2 = 2
• รอบที่ 2: i = 3, result = 2 × 3 = 6
• รอบที่ 3: i = 4, result = 6 × 4 = 24
• รอบที่ 4: i = 5, result = 24 × 5 = 120

แนวคิดสำคัญ: iteration ไม่ต้องสร้าง call stack เพิ่ม — ทุกอย่างเกิดขึ้นภายในฟังก์ชันเดิม ตัวแปร i และ result ถูกอัปเดตทับค่ากันไปเรื่อย ๆ ทำให้ใช้หน่วยความจำน้อย (O(1))

while loop — เมื่อไม่รู้จำนวนรอบล่วงหน้า

while loop เหมาะกับสถานการณ์ที่เราไม่รู้ล่วงหน้าว่าต้องวนกี่รอบ แต่รู้จักเงื่อนไขหยุด — เช่น อ่านข้อมูลเรื่อย ๆ จนกว่าจะหมด, รอ input จากผู้ใช้, หรือหาตัวแรกที่เข้าเงื่อนไข

// ตัวอย่าง: หาว่าต้องคูณ 2 กี่ครั้งถึงจะเกิน 1000
function stepsToExceed1000(start) {
  let value = start;
  let steps = 0;

  while (value <= 1000) {
    value *= 2;
    steps += 1;
  }

  return steps;
}

console.log(stepsToExceed1000(1));  // 10 (2^10 = 1024)
console.log(stepsToExceed1000(500)); // 1  (500×2 = 1000 → เกินตอน 1000×2)

จุดที่ต้องระวัง: • while ตรวจเงื่อนไขก่อนทำเสมอ — ถ้าเงื่อนไขเป็นเท็จตั้งแต่แรก จะไม่เข้าลูปเลย • ต้องมีโค้ดภายในลูปที่พาเข้าใกล้จุดหยุด — ไม่งั้นจะกลายเป็น infinite loop

do...while — รับประกันอย่างน้อย 1 รอบ

do...while ทำงานเหมือน while กลับด้าน — ทำก่อนหนึ่งรอบแล้วค่อยตรวจเงื่อนไข เหมาะกับงานที่ต้องทำงานอย่างน้อยครั้งเดียวเสมอ เช่น ทอยลูกเต๋าจนกว่าจะออก 6 หรืออ่านบรรทัดแรกของไฟล์

// ตัวอย่าง: สุ่มเลข 1-6 จนกว่าจะได้ 6
function rollUntilSix() {
  let totalRolls = 0;
  let value;

  do {
    value = Math.floor(Math.random() * 6) + 1;
    totalRolls += 1;
    console.log("รอบที่", totalRolls, "ได้", value);
  } while (value !== 6);

  return totalRolls;
}

rollUntilSix();

สรุปสั้น: • for — รู้จำนวนรอบแน่นอน (อาเรย์, range) • while — ไม่รู้จำนวนรอบ แต่รู้เงื่อนไขหยุด • do...while — ต้องทำงานอย่างน้อย 1 ครั้งก่อนเช็กเงื่อนไข

Time & Space Complexity ของ Iteration

• Best Case: O(1) — เงื่อนไขเป็นเท็จตั้งแต่แรก (loop ไม่รันเลย)
• Average Case: O(n) — ส่วนใหญ่ต้องวนประมาณ n รอบ (หรือครึ่งหนึ่งขึ้นอยู่กับเงื่อนไขหยุด)
• Worst Case: O(n) — ต้องวนจนครบทุกรอบถึงจะหยุด

Space Complexity = O(1) — ฟังก์ชันแบบ iterative ใช้ตัวแปรเพิ่มแค่ตัวนับและตัวสะสมผลลัพธ์ ไม่ต้องสร้างโครงสร้างข้อมูลใหม่ ไม่ต้องเพิ่ม call stack เหมือน recursion

ข้อควรระวังและความผิดพลาดที่พบบ่อย

กฎสำคัญที่ต้องจำ

ทบทวนความเข้าใจ

แบบฝึกหัด: ฝึกเขียน Iteration

แบบฝึกหัด 3 ข้อนี้จะช่วยให้คุณเขียน Iteration ได้คล่อง — เริ่มจาก factorial พื้นฐาน ไปจนถึงผลรวม และการหาค่าสูงสุดในอาเรย์