Queue คือโครงสร้างข้อมูลที่รับสมาชิกเข้าท้ายและนำสมาชิกออกที่หัวตามลำดับเวลาเข้า

Mental model: เหมือนคิวซื้อของ คนมาก่อนจะถูกบริการก่อน

Recap: Queue เน้นความยุติธรรมตามลำดับเข้าใช้งาน

FIFO คือ First In, First Out เข้าเป็นคนแรกต้องออกก่อน

Mental model: คิวรถที่ด่านเก็บเงินทางด่วน

Recap: FIFO เป็นกฎหลักของ Queue

Queue พื้นฐานมีพื้นที่เก็บข้อมูลและ operation สำคัญคือ enqueue, dequeue, peek, isEmpty, size

Mental model: มี 2 ปลายหลัก: front สำหรับออก และ rear สำหรับเข้า

Recap: API ของ Queue ชัดและเหมาะกับงานคิว

Front ชี้ข้อมูลตัวหน้าสุด ส่วน Rear ชี้ตำแหน่งท้ายสุดของคิว

Mental model: front = หัวคิว, rear = ท้ายคิว

Recap: enqueue ทำงานฝั่ง rear, dequeue ทำงานฝั่ง front

enqueue คือการเพิ่มสมาชิกใหม่เข้าไปด้านท้ายของ queue

Mental model: คนใหม่เข้าต่อท้ายคิว

class Queue<T> {
  private items: T[] = [];

  enqueue(value: T) {
    this.items.push(value);
  }
}

Recap: enqueue เพิ่มลำดับงานโดยไม่กระทบหัวคิว

dequeue คือการนำสมาชิกหน้าสุดออกจากคิว

Mental model: บริการคนที่อยู่หัวคิวก่อน

dequeue() {
  return this.items.shift();
}

Recap: dequeue ลดขนาด queue และขยับหัวคิว

peek อ่านสมาชิก front โดยไม่ลบ

Mental model: ดูว่าใครอยู่หัวคิวตอนนี้

peek() {
  return this.items[0];
}

Recap: ใช้ peek เพื่อตัดสินใจก่อน dequeue

ตรวจจากขนาดว่าเท่ากับ 0 หรือไม่

Mental model: ไม่มีสมาชิกแปลว่าไม่มีงานรอคิว

isEmpty() {
  return this.items.length === 0;
}

Recap: เช็กคิวว่างก่อน dequeue ทุกครั้ง

อ่านจำนวนสมาชิกทั้งหมดในคิวปัจจุบัน

Mental model: นับจำนวนงานที่รออยู่

size() {
  return this.items.length;
}

Recap: size ใช้ควบคุม loop และ monitor load ได้ดี

Array เข้าถึง index ได้อิสระ ส่วน Queue จำกัดรูปแบบใช้งานตาม FIFO เพื่อรักษาลำดับคิว

Mental model: Queue คือ policy บน container ไม่ใช่แค่โครงสร้างเก็บข้อมูล

Recap: Queue คุมวินัยการเข้าออกของข้อมูล

ใช้ array เป็น storage และเปิด API เฉพาะ enqueue/dequeue/peek เพื่อคุม behavior

Mental model: ซ่อน method ที่ทำลายกติกา FIFO

Recap: array-based queue ทำง่าย แต่อาจมีค่าใช้จ่าย shift

เก็บทั้ง head และ tail ของ linked list แล้วทำ enqueue ที่ tail, dequeue ที่ head

Mental model: front=head และ rear=tail

type Node<T> = { value: T; next: Node<T> | null };

class LinkedQueue<T> {
  private head: Node<T> | null = null;
  private tail: Node<T> | null = null;

  enqueue(value: T) {
    const node: Node<T> = { value, next: null };
    if (!this.tail) {
      this.head = node;
      this.tail = node;
      return;
    }
    this.tail.next = node;
    this.tail = node;
  }
}

Recap: linked-list queue ให้ enqueue/dequeue เป็น O(1) ได้ง่าย

ถ้าออกแบบถูก (linked list หรือ circular buffer) enqueue/dequeue/peek ทำได้ O(1)

Mental model: แตะเฉพาะ front/rear ไม่ต้องเดินทั้งคิว

Recap: ประสิทธิภาพขึ้นกับ implementation ไม่ใช่ชื่อโครงสร้างอย่างเดียว

การใช้ `shift()` บน array อาจมีต้นทุน O(n) เพราะต้องเลื่อนสมาชิกทั้งหมด

Mental model: ดึงหัวคิวแล้วข้อมูลที่เหลือขยับทั้งแถว

Recap: คิวงานเยอะควรหลีกเลี่ยง shift ซ้ำๆ

Circular queue ใช้อาร์เรย์แบบวนรอบ โดย front/rear ขยับแบบ modulo ตามความจุ

Mental model: ปลายอาร์เรย์ต่อกับต้นอาร์เรย์เป็นวงแหวน

Recap: circular queue ลดปัญหาช่องว่างทิ้งท้าย

enqueue/dequeue ขยับ pointer และวนกลับ 0 เมื่อถึงท้าย buffer

Mental model: เดิน pointer บนวงกลม ไม่ใช่เส้นตรง

rear = (rear + 1) % capacity;
front = (front + 1) % capacity;

Recap: คุมเงื่อนไขเต็ม/ว่างให้ดีคือหัวใจ

Deque คือคิวที่เพิ่ม/ลบได้ทั้งหัวและท้าย (double-ended queue)

Mental model: คิวที่ยืดหยุ่นขึ้นสองทิศทาง

Recap: deque เหมาะกับ sliding window และ monotonic queue

Priority queue ดึงข้อมูลตามลำดับความสำคัญ ไม่ได้ดึงตามเวลาเข้าเสมอ

Mental model: คิวฉุกเฉินของโรงพยาบาลที่ priority มาก่อน

Recap: priority queue มักใช้ heap เป็น implementation หลัก

Queue เป็น FIFO ส่วน Stack เป็น LIFO จึงให้พฤติกรรมและ use case ต่างกัน

Mental model: Queue = ลำดับเวลา, Stack = ย้อนล่าสุด

Recap: ระบุรูปแบบเข้าออกของข้อมูลก่อนเลือกโครงสร้าง

เช่น task scheduling, event processing, message queue, network packet buffering

Mental model: งานที่ต้องรับ-รอ-ประมวลผลตามลำดับเวลา

Recap: Queue เด่นในระบบ asynchronous และ producer-consumer

BFS ใช้ queue เพื่อเก็บโหนดที่ค้นพบแล้วรอสำรวจถัดไปตามลำดับชั้น

Mental model: สำรวจกราฟแบบเป็นชั้นจากต้นทางออกไป

function bfs(start: number, graph: number[][]) {
  const q: number[] = [start];
  const visited = new Set<number>([start]);

  while (q.length) {
    const node = q.shift()!;
    for (const next of graph[node] ?? []) {
      if (!visited.has(next)) {
        visited.add(next);
        q.push(next);
      }
    }
  }
}

Recap: ไม่มี queue ก็ไม่ใช่ BFS แบบคลาสสิก

ระบบจริงใช้คิวในงาน call center, printer spool, API rate limiting, background jobs

Mental model: รับงานก่อนแล้วทยอยประมวลผลตามลำดับหรือ policy ที่กำหนด

Recap: Queue ทำให้ระบบรับโหลดได้เสถียรขึ้น

รักษาลำดับยุติธรรม, operation หลักเร็วเมื่อออกแบบถูก, เหมาะกับงาน async และ buffering

Mental model: โครงสร้างเรียบง่ายแต่รองรับระบบจริงได้ดี

Recap: Queue ช่วย decouple producer และ consumer ได้ดี

ไม่เหมาะกับ random access และถ้า implementation ไม่ดีอาจมี bottleneck เรื่องประสิทธิภาพ

Mental model: Queue ตั้งใจจำกัดการเข้าถึงเพื่อคุมลำดับ

Recap: ถ้าโจทย์ต้องเข้าถึงข้อมูลกลางคิวบ่อย ควรใช้โครงสร้างอื่น

ถ้าต้องการฝึกแบบมี runtime checks ให้ไป Queue Lab ซึ่งมี 4 โจทย์เรียงระดับจาก operation พื้นฐานไปถึงการจำลองคิวงาน

เช่น dequeue จากคิวว่าง, สับสน front/rear, ใช้ shift ซ้ำในงานใหญ่, และไม่จัดการ overflow/underflow

Mental model: เขียน guard สำหรับ empty/full เสมอในโค้ด production

Recap: edge case รอบ front/rear คือจุดพลาดยอดนิยม