พื้นฐานบทที่ 3Best / Average / Worst case

Best / Average / Worst case แบบเข้าใจง่ายสำหรับผู้เริ่มต้น

บทนี้จะพาคุณเข้าใจว่าอัลกอริทึมเดียวกันทำไมบางครั้งเร็ว บางครั้งช้า โดยมองครบทั้งกรณีดีที่สุด (Best), กรณีเฉลี่ย (Average), และกรณีแย่ที่สุด (Worst) พร้อมตัวอย่างจริง, โค้ด JavaScript, ตารางเปรียบเทียบ, และแบบฝึกหัดพร้อมแนวเฉลย

1. Best case คืออะไร

Best case คือสถานการณ์ที่ข้อมูลเข้าเอื้อมากที่สุด ทำให้อัลกอริทึมทำงานน้อยที่สุด เหมือนคุณหาหนังสือแล้วหยิบเจอเล่มที่ต้องการทันทีที่ชั้นแรก

มันช่วยบอก "เพดานล่าง" ว่าเร็วสุดเป็นไปได้แค่ไหน แต่ไม่ได้การันตีว่าจะเกิดแบบนี้ทุกครั้ง

2. Average case คืออะไร

Average case คือประสิทธิภาพเฉลี่ยที่คาดว่าจะเจอในสถานการณ์ทั่วไป ถ้ารูปแบบข้อมูลเข้าเกิดแบบธรรมดา ๆ

มุมนี้สำคัญมาก เพราะมักใกล้กับประสบการณ์ผู้ใช้จริงที่สุด แต่ต้องระบุสมมติฐานให้ชัดว่าข้อมูล "ทั่วไป" หมายถึงอะไร

3. Worst case คืออะไร

Worst case คือกรณีที่ข้อมูลเข้าไม่เป็นใจที่สุด ทำให้อัลกอริทึมต้องทำงานมากที่สุด

มันคือ "ขอบเขตบน" ของต้นทุนการทำงาน ใช้ประเมินความเสี่ยงว่าต่อให้เจอสถานการณ์แย่สุด ระบบยังรับได้หรือไม่

4. ทำไมทั้ง 3 แบบจึงสำคัญ

Best

บอกศักยภาพสูงสุดเมื่อทุกอย่างเข้าทาง เหมาะกับการมองโอกาสการ optimize

Average

สะท้อนการใช้งานส่วนใหญ่ ช่วยคาดการณ์ประสบการณ์ผู้ใช้ในโลกจริง

Worst

ใช้ตั้งการ์ดความเสี่ยงและวาง capacity เพื่อไม่ให้ระบบล่มเมื่อเจอข้อมูลแย่

5. ตัวอย่างจากชีวิตจริง

ลองนึกถึงการหาเสื้อสีขาวในตู้ผ้า:

- Best case: เปิดตู้แล้วเจอที่ตัวแรก
- Average case: ต้องหยิบดูหลายตัวกว่าจะเจอ
- Worst case: ดูครบทุกตัวแล้วไม่เจอ หรือเจอตัวสุดท้าย

จะเห็นว่า "งานที่ต้องทำ" เปลี่ยนไปตามรูปแบบ input แม้อัลกอริทึมเหมือนเดิม

6. ตัวอย่างด้วย Linear Search

Linear Search คือการไล่ดูข้อมูลทีละตัวจากซ้ายไปขวา แล้วหยุดทันทีเมื่อเจอเป้าหมาย ถ้าไม่เจอเลยก็ต้องตรวจครบทุกตัว

JavaScript: Linear SearchJS

โค้ดพื้นฐานสำหรับอธิบายทั้ง Best / Average / Worst case

function linearSearch(arr, target) {
  for (let i = 0; i < arr.length; i += 1) {
    if (arr[i] === target) {
      return i;
    }
  }

  return -1;
}

7. กรณีหาเจอทันที, หาเจอช่วงกลาง, หาไม่เจอหรืออยู่ท้ายสุด

ภาพเปรียบเทียบ 3 กรณีของการค้นหาใน array

ด้านล่างคือภาพกล่องข้อมูลและลูกศร แสดงจำนวนขั้นตอนที่ต่างกันตามตำแหน่งของ target

กรณีเจอตัวแรก (Best)

ตรวจเพียงช่องแรกแล้วจบ

ช่องที่ตรวจแล้วช่องเป้าหมาย (target = 4)

กรณีเจอช่วงกลาง (Average โดยประมาณ)

ต้องไล่ตรวจหลายช่องก่อนเจอ

ช่องที่ตรวจแล้วช่องเป้าหมาย (target = 11)

กรณีเจอท้ายสุด/ไม่เจอ (Worst)

ต้องตรวจเกือบทั้งหมดหรือทั้งหมด

ช่องที่ตรวจแล้วช่องเป้าหมาย (target = 30)

เจอทันที

ตรวจ 1 ครั้งแล้วหยุด จึงเป็น O(1)

เจอช่วงกลาง

โดยเฉลี่ยต้องตรวจประมาณ n/2 ครั้ง จัดอยู่ใน O(n)

เจอท้ายสุด/ไม่เจอ

ต้องตรวจครบ n ครั้ง เป็น Worst case ของ Linear Search: O(n)

8. ตัวอย่างเพิ่มด้วย Bubble Sort

Bubble Sort เทียบค่าที่อยู่ติดกันและสลับเมื่อเรียงผิด ถ้าข้อมูลเกือบเรียงอยู่แล้ว (และมี swapped flag) จะจบเร็วขึ้น แต่ถ้าข้อมูลกลับด้านจะต้องสลับจำนวนมาก

JavaScript: Bubble Sort (optimized)JS

ใช้ swapped flag เพื่อหยุดเร็วเมื่อข้อมูลเรียงแล้ว

function bubbleSort(arr) {
  const result = [...arr];

  for (let pass = 0; pass < result.length - 1; pass += 1) {
    let swapped = false;

    for (let i = 0; i < result.length - 1 - pass; i += 1) {
      if (result[i] > result[i + 1]) {
        const temp = result[i];
        result[i] = result[i + 1];
        result[i + 1] = temp;
        swapped = true;
      }
    }

    if (!swapped) {
      break;
    }
  }

  return result;
}

9. ตัวอย่างโค้ด JavaScript พร้อมอธิบาย

Linear Search อธิบายทีละบล็อก

- ลูป `for` ทำหน้าที่ไล่ตรวจสมาชิกทีละตัว
- เงื่อนไข `arr[i] === target` คือ operation หลักที่นับในการวิเคราะห์
- `return i` ทำให้หยุดทันทีเมื่อเจอ (เหตุผลที่ Best case เร็วมาก)
- `return -1` หมายถึงตรวจครบแล้วยังไม่เจอ

Bubble Sort อธิบายทีละบล็อก

- ลูปนอกควบคุมจำนวนรอบ (pass)
- ลูปในเปรียบเทียบสมาชิกที่ติดกัน
- ถ้าเรียงผิดให้สลับและตั้ง `swapped = true`
- ถ้าจบรอบแล้วยัง `swapped = false` แปลว่าเรียงแล้วและหยุดได้

10. เปรียบเทียบทั้ง 3 กรณีในรูปแบบตาราง

กรณี	รูปแบบ input	Linear Search	Bubble Sort	สรุป Big-O
กรณีดีที่สุด (Best case)	target อยู่ตำแหน่งแรก	ตรวจ 1 ครั้งแล้วจบ	ข้อมูลเรียงอยู่แล้ว + ใช้ swapped flag จบเร็ว	Linear: O(1), Bubble: O(n)
กรณีเฉลี่ย (Average case)	target มักอยู่ช่วงกลาง / ข้อมูลกระจายทั่วไป	ตรวจประมาณ n/2 ครั้ง	ยังต้องเทียบหลายรอบ	Linear: O(n), Bubble: O(n²)
กรณีแย่ที่สุด (Worst case)	target อยู่ท้ายสุดหรือไม่เจอ / ข้อมูลกลับด้าน	ตรวจครบ n ครั้ง	ต้องเทียบและสลับหนักสุดเกือบทุกรอบ	Linear: O(n), Bubble: O(n²)

11. ทำไมหลายครั้งจึงเน้น Worst case

- เพราะใช้วางแผนทรัพยากรให้ปลอดภัยในวันที่ระบบเจอโหลดหนัก
- เพราะเป็นขอบเขตบนที่ไม่ต้องพึ่งดวงหรือสมมติฐานข้อมูลมากเกินไป
- เพราะช่วยเปรียบเทียบอัลกอริทึมได้ยุติธรรมในสถานการณ์แย่

12. Average case ยากตรงไหนในการวิเคราะห์

- ต้องรู้ distribution ของข้อมูลเข้า ซึ่งงานจริงมักไม่สวยและเปลี่ยนได้
- ต้องกำหนดสมมติฐาน เช่น target กระจายสม่ำเสมอหรือไม่
- ถ้าสมมติฐานผิด ค่า Average ที่คำนวณได้อาจไม่สะท้อนการใช้งานจริง

13. ข้อผิดพลาดที่ผู้เริ่มต้นมักสับสน

- คิดว่า Best case คือเวลาจริงที่จะเกิดทุกครั้ง ทั้งที่เป็นแค่กรณีที่ดีที่สุดเท่านั้น
- เห็น Best case เร็วมากแล้วสรุปว่าอัลกอริทึมนี้เร็วเสมอ โดยไม่ดู Average/Worst
- สับสนระหว่าง Big-O กับเวลาจริงเป็นวินาที (Big-O คือแนวโน้มการโต)
- ลืมบอกสมมติฐานของ Average case เช่น ข้อมูลกระจายแบบไหน
- คิดว่า Worst case แปลว่าจะเกิดบ่อย ทั้งที่มันคือขอบเขตบนเพื่อวางแผนความเสี่ยง

14. สรุปท้ายบทแบบจำง่าย

- Best บอกว่าเร็วสุดได้แค่ไหน
- Average บอกว่าส่วนใหญ่จะเร็วประมาณไหน (ถ้าสมมติฐานถูก)
- Worst บอกว่าช้าที่สุดแค่ไหน และช่วยจัดการความเสี่ยง
- Input ต่างกัน อัลกอริทึมเดียวกันก็ให้ประสิทธิภาพต่างกันได้มาก
- เวลาอธิบายอัลกอริทึม ให้รายงาน Worst ก่อน แล้วตามด้วย Average และ Best

15. แบบฝึกหัด 4 ข้อ พร้อมแนวเฉลย

ข้อ 1

ให้ arr = [8, 3, 10, 4, 9] และ target = 8 ถ้าใช้ Linear Search จะเป็นกรณีอะไร และตรวจทั้งหมดกี่ครั้ง?

แนวเฉลย

เป็น Best case เพราะเจอที่ตำแหน่งแรก ตรวจเพียง 1 ครั้ง แล้วคืน index 0

ข้อ 2

ให้ arr = [8, 3, 10, 4, 9] และ target = 9 ถ้าใช้ Linear Search จะใกล้เคียงกรณีไหน และเพราะอะไร?

แนวเฉลย

ใกล้ Worst case เพราะ target อยู่ท้ายอาเรย์ ต้องไล่ตรวจเกือบครบทุกตัวก่อนเจอ

ข้อ 3

Bubble Sort (มี swapped flag) กับข้อมูล [1, 2, 3, 4, 5] ควรเป็น Best, Average หรือ Worst case? อธิบายสั้น ๆ

แนวเฉลย

เป็น Best case ของ Bubble Sort แบบ optimized เพราะ pass แรกไม่เกิดการสลับ จึงหยุดทันที

ข้อ 4

ทำไมตอนรีวิวอัลกอริทึมในระบบ production เรามักรายงาน Worst case ก่อน Average case?

แนวเฉลย

เพราะ Worst case ให้ขอบเขตบนของเวลา/ทรัพยากร ช่วยประเมินความเสี่ยงและวาง capacity ได้ปลอดภัยก่อน

พื้นฐานบทที่ 3Best / Average / Worst case

Best / Average / Worst case แบบเข้าใจง่ายสำหรับผู้เริ่มต้น

1. Best case คืออะไร

2. Average case คืออะไร

3. Worst case คืออะไร

4. ทำไมทั้ง 3 แบบจึงสำคัญ

Best

บอกศักยภาพสูงสุดเมื่อทุกอย่างเข้าทาง เหมาะกับการมองโอกาสการ optimize

Average

สะท้อนการใช้งานส่วนใหญ่ ช่วยคาดการณ์ประสบการณ์ผู้ใช้ในโลกจริง

Worst

ใช้ตั้งการ์ดความเสี่ยงและวาง capacity เพื่อไม่ให้ระบบล่มเมื่อเจอข้อมูลแย่

5. ตัวอย่างจากชีวิตจริง

ลองนึกถึงการหาเสื้อสีขาวในตู้ผ้า:

- Best case: เปิดตู้แล้วเจอที่ตัวแรก
- Average case: ต้องหยิบดูหลายตัวกว่าจะเจอ
- Worst case: ดูครบทุกตัวแล้วไม่เจอ หรือเจอตัวสุดท้าย

จะเห็นว่า "งานที่ต้องทำ" เปลี่ยนไปตามรูปแบบ input แม้อัลกอริทึมเหมือนเดิม

6. ตัวอย่างด้วย Linear Search

JavaScript: Linear SearchJS

โค้ดพื้นฐานสำหรับอธิบายทั้ง Best / Average / Worst case

function linearSearch(arr, target) {
  for (let i = 0; i < arr.length; i += 1) {
    if (arr[i] === target) {
      return i;
    }
  }

  return -1;
}

7. กรณีหาเจอทันที, หาเจอช่วงกลาง, หาไม่เจอหรืออยู่ท้ายสุด

ภาพเปรียบเทียบ 3 กรณีของการค้นหาใน array

กรณีเจอตัวแรก (Best)

ตรวจเพียงช่องแรกแล้วจบ

ช่องที่ตรวจแล้วช่องเป้าหมาย (target = 4)

กรณีเจอช่วงกลาง (Average โดยประมาณ)

ต้องไล่ตรวจหลายช่องก่อนเจอ

ช่องที่ตรวจแล้วช่องเป้าหมาย (target = 11)

กรณีเจอท้ายสุด/ไม่เจอ (Worst)

ต้องตรวจเกือบทั้งหมดหรือทั้งหมด

ช่องที่ตรวจแล้วช่องเป้าหมาย (target = 30)

เจอทันที

ตรวจ 1 ครั้งแล้วหยุด จึงเป็น O(1)

เจอช่วงกลาง

โดยเฉลี่ยต้องตรวจประมาณ n/2 ครั้ง จัดอยู่ใน O(n)

เจอท้ายสุด/ไม่เจอ

ต้องตรวจครบ n ครั้ง เป็น Worst case ของ Linear Search: O(n)

8. ตัวอย่างเพิ่มด้วย Bubble Sort

JavaScript: Bubble Sort (optimized)JS

ใช้ swapped flag เพื่อหยุดเร็วเมื่อข้อมูลเรียงแล้ว

function bubbleSort(arr) {
  const result = [...arr];

  for (let pass = 0; pass < result.length - 1; pass += 1) {
    let swapped = false;

    for (let i = 0; i < result.length - 1 - pass; i += 1) {
      if (result[i] > result[i + 1]) {
        const temp = result[i];
        result[i] = result[i + 1];
        result[i + 1] = temp;
        swapped = true;
      }
    }

    if (!swapped) {
      break;
    }
  }

  return result;
}

9. ตัวอย่างโค้ด JavaScript พร้อมอธิบาย

Linear Search อธิบายทีละบล็อก

- ลูป `for` ทำหน้าที่ไล่ตรวจสมาชิกทีละตัว
- เงื่อนไข `arr[i] === target` คือ operation หลักที่นับในการวิเคราะห์
- `return i` ทำให้หยุดทันทีเมื่อเจอ (เหตุผลที่ Best case เร็วมาก)
- `return -1` หมายถึงตรวจครบแล้วยังไม่เจอ

Bubble Sort อธิบายทีละบล็อก

- ลูปนอกควบคุมจำนวนรอบ (pass)
- ลูปในเปรียบเทียบสมาชิกที่ติดกัน
- ถ้าเรียงผิดให้สลับและตั้ง `swapped = true`
- ถ้าจบรอบแล้วยัง `swapped = false` แปลว่าเรียงแล้วและหยุดได้

10. เปรียบเทียบทั้ง 3 กรณีในรูปแบบตาราง

กรณี	รูปแบบ input	Linear Search	Bubble Sort	สรุป Big-O
กรณีดีที่สุด (Best case)	target อยู่ตำแหน่งแรก	ตรวจ 1 ครั้งแล้วจบ	ข้อมูลเรียงอยู่แล้ว + ใช้ swapped flag จบเร็ว	Linear: O(1), Bubble: O(n)
กรณีเฉลี่ย (Average case)	target มักอยู่ช่วงกลาง / ข้อมูลกระจายทั่วไป	ตรวจประมาณ n/2 ครั้ง	ยังต้องเทียบหลายรอบ	Linear: O(n), Bubble: O(n²)
กรณีแย่ที่สุด (Worst case)	target อยู่ท้ายสุดหรือไม่เจอ / ข้อมูลกลับด้าน	ตรวจครบ n ครั้ง	ต้องเทียบและสลับหนักสุดเกือบทุกรอบ	Linear: O(n), Bubble: O(n²)

11. ทำไมหลายครั้งจึงเน้น Worst case

- เพราะใช้วางแผนทรัพยากรให้ปลอดภัยในวันที่ระบบเจอโหลดหนัก
- เพราะเป็นขอบเขตบนที่ไม่ต้องพึ่งดวงหรือสมมติฐานข้อมูลมากเกินไป
- เพราะช่วยเปรียบเทียบอัลกอริทึมได้ยุติธรรมในสถานการณ์แย่

12. Average case ยากตรงไหนในการวิเคราะห์

- ต้องรู้ distribution ของข้อมูลเข้า ซึ่งงานจริงมักไม่สวยและเปลี่ยนได้
- ต้องกำหนดสมมติฐาน เช่น target กระจายสม่ำเสมอหรือไม่
- ถ้าสมมติฐานผิด ค่า Average ที่คำนวณได้อาจไม่สะท้อนการใช้งานจริง

13. ข้อผิดพลาดที่ผู้เริ่มต้นมักสับสน

- คิดว่า Best case คือเวลาจริงที่จะเกิดทุกครั้ง ทั้งที่เป็นแค่กรณีที่ดีที่สุดเท่านั้น
- เห็น Best case เร็วมากแล้วสรุปว่าอัลกอริทึมนี้เร็วเสมอ โดยไม่ดู Average/Worst
- สับสนระหว่าง Big-O กับเวลาจริงเป็นวินาที (Big-O คือแนวโน้มการโต)
- ลืมบอกสมมติฐานของ Average case เช่น ข้อมูลกระจายแบบไหน
- คิดว่า Worst case แปลว่าจะเกิดบ่อย ทั้งที่มันคือขอบเขตบนเพื่อวางแผนความเสี่ยง

14. สรุปท้ายบทแบบจำง่าย

- Best บอกว่าเร็วสุดได้แค่ไหน
- Average บอกว่าส่วนใหญ่จะเร็วประมาณไหน (ถ้าสมมติฐานถูก)
- Worst บอกว่าช้าที่สุดแค่ไหน และช่วยจัดการความเสี่ยง
- Input ต่างกัน อัลกอริทึมเดียวกันก็ให้ประสิทธิภาพต่างกันได้มาก
- เวลาอธิบายอัลกอริทึม ให้รายงาน Worst ก่อน แล้วตามด้วย Average และ Best

15. แบบฝึกหัด 4 ข้อ พร้อมแนวเฉลย

ข้อ 1

ให้ arr = [8, 3, 10, 4, 9] และ target = 8 ถ้าใช้ Linear Search จะเป็นกรณีอะไร และตรวจทั้งหมดกี่ครั้ง?

แนวเฉลย

เป็น Best case เพราะเจอที่ตำแหน่งแรก ตรวจเพียง 1 ครั้ง แล้วคืน index 0

ข้อ 2

ให้ arr = [8, 3, 10, 4, 9] และ target = 9 ถ้าใช้ Linear Search จะใกล้เคียงกรณีไหน และเพราะอะไร?

แนวเฉลย

ใกล้ Worst case เพราะ target อยู่ท้ายอาเรย์ ต้องไล่ตรวจเกือบครบทุกตัวก่อนเจอ

ข้อ 3

Bubble Sort (มี swapped flag) กับข้อมูล [1, 2, 3, 4, 5] ควรเป็น Best, Average หรือ Worst case? อธิบายสั้น ๆ

แนวเฉลย

เป็น Best case ของ Bubble Sort แบบ optimized เพราะ pass แรกไม่เกิดการสลับ จึงหยุดทันที

ข้อ 4

ทำไมตอนรีวิวอัลกอริทึมในระบบ production เรามักรายงาน Worst case ก่อน Average case?

แนวเฉลย

Data Structures & Algorithms

Best / Average / Worst case แบบเข้าใจง่ายสำหรับผู้เริ่มต้น

1. Best case คืออะไร

2. Average case คืออะไร

3. Worst case คืออะไร

4. ทำไมทั้ง 3 แบบจึงสำคัญ

5. ตัวอย่างจากชีวิตจริง

6. ตัวอย่างด้วย Linear Search

7. กรณีหาเจอทันที, หาเจอช่วงกลาง, หาไม่เจอหรืออยู่ท้ายสุด

8. ตัวอย่างเพิ่มด้วย Bubble Sort

9. ตัวอย่างโค้ด JavaScript พร้อมอธิบาย

10. เปรียบเทียบทั้ง 3 กรณีในรูปแบบตาราง

11. ทำไมหลายครั้งจึงเน้น Worst case

12. Average case ยากตรงไหนในการวิเคราะห์

13. ข้อผิดพลาดที่ผู้เริ่มต้นมักสับสน

14. สรุปท้ายบทแบบจำง่าย

15. แบบฝึกหัด 4 ข้อ พร้อมแนวเฉลย

Loading

Data Structures & Algorithms

Best / Average / Worst case แบบเข้าใจง่ายสำหรับผู้เริ่มต้น

1. Best case คืออะไร

2. Average case คืออะไร

3. Worst case คืออะไร

4. ทำไมทั้ง 3 แบบจึงสำคัญ

5. ตัวอย่างจากชีวิตจริง

6. ตัวอย่างด้วย Linear Search

7. กรณีหาเจอทันที, หาเจอช่วงกลาง, หาไม่เจอหรืออยู่ท้ายสุด

8. ตัวอย่างเพิ่มด้วย Bubble Sort

9. ตัวอย่างโค้ด JavaScript พร้อมอธิบาย

10. เปรียบเทียบทั้ง 3 กรณีในรูปแบบตาราง

11. ทำไมหลายครั้งจึงเน้น Worst case

12. Average case ยากตรงไหนในการวิเคราะห์

13. ข้อผิดพลาดที่ผู้เริ่มต้นมักสับสน

14. สรุปท้ายบทแบบจำง่าย

15. แบบฝึกหัด 4 ข้อ พร้อมแนวเฉลย