Stack คือโครงสร้างข้อมูลที่เข้าถึงและแก้ไขข้อมูลได้ที่ปลายด้านเดียวเท่านั้น

Mental model: นึกภาพกองจานซ้อนกัน หยิบได้จากใบบนสุด

Recap: Stack คือโครงสร้างข้อมูลแบบปลายเดียว

LIFO ย่อมาจาก Last In, First Out คือเข้าหลังออกก่อน

Mental model: ของที่วางล่าสุดจะอยู่บนสุดและถูกหยิบก่อน

Recap: LIFO คือกฎหลักที่ทำให้ Stack ต่างจาก Queue

Stack พื้นฐานมี container เก็บข้อมูลและ operation หลักไม่กี่ตัว

Mental model: มีช่องหลักแค่ push, pop, peek, isEmpty, size

Recap: API เล็กแต่ใช้งานได้กว้างมาก

Top คือสมาชิกตัวบนสุดที่พร้อมถูกอ่านหรือเอาออก

Mental model: ปลาย active ของ stack อยู่ที่ top เสมอ

Recap: ทุก operation หลักทำงานรอบ top

push คือการเพิ่มข้อมูลใหม่เข้าไปบนสุดของ stack

Mental model: วางจานเพิ่มบนกองเดิม

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

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

Recap: push เพิ่มข้อมูลที่ top

pop คือการนำสมาชิกบนสุดออกและคืนค่านั้น

Mental model: หยิบจานบนสุดออกจากกอง

pop() {
  return this.items.pop();
}

Recap: pop เปลี่ยนโครงสร้าง stack และลดขนาดลง

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

Mental model: มองดูจานบนสุดโดยไม่หยิบ

peek() {
  return this.items[this.items.length - 1];
}

Recap: peek ใช้เช็กสถานะก่อนตัดสินใจ pop

เช็กจากขนาดว่าเป็น 0 หรือไม่

Mental model: ไม่มีสมาชิกแปลว่า stack ว่าง

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

Recap: isEmpty เป็นเงื่อนไขพื้นฐานก่อน pop/peek

อ่านจำนวนสมาชิกทั้งหมดใน stack

Mental model: นับจำนวนจานที่ซ้อนอยู่ตอนนี้

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

Recap: size ช่วยกำหนดเงื่อนไข loop และ stop condition

Array เข้าถึง index ได้อิสระ แต่ Stack จำกัดการใช้งานให้ทำงานที่ปลายด้านเดียว

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

Recap: Stack ช่วยบังคับรูปแบบการใช้ข้อมูลให้ถูกโจทย์

ใช้ array เป็น backing store แล้ว expose เฉพาะ push/pop/peek

Mental model: ซ่อน method ที่ไม่ต้องการเพื่อรักษากติกา LIFO

Recap: implementation ด้วย array ทำง่ายและนิยมที่สุด

ใช้ head เป็น top ของ stack แล้วทำ push/pop ที่ head เพื่อให้ O(1)

Mental model: head คือ top ของ stack ใน linked-list implementation

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

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

  push(value: T) {
    this.head = { value, next: this.head };
  }
}

Recap: linked list เหมาะเมื่ออยากเลี่ยงการขยาย capacity ของ array

operation หลักของ stack ปกติเป็น O(1)

Mental model: แตะเฉพาะ top จึงไม่ต้องเดินทั้งโครงสร้าง

Recap: จุดแข็งของ stack คือ operation คงที่ที่ปลายเดียว

เช่น undo/redo, bracket matching, backtracking, parsing expression

Mental model: งานที่ต้องย้อนกลับ step ล่าสุดเหมาะกับ LIFO

Recap: ถ้าโจทย์พูดถึงย้อนลำดับล่าสุด ให้คิดถึง stack ก่อน

runtime ใช้ call stack เก็บ frame ของฟังก์ชันที่กำลังทำงาน

Mental model: เรียกฟังก์ชันใหม่คือ push frame, return คือ pop frame

Recap: call stack คือ stack ที่ภาษาใช้จริงทุกโปรแกรม

แต่ละ recursion call จะสร้าง frame ใหม่ใน call stack จนถึง base case แล้วทยอยคืน

Mental model: recursion คือการใช้ stack แบบอัตโนมัติโดย runtime

Recap: recursion ลึกเกินไปอาจเกิด stack overflow

push วงเล็บเปิด และ pop เพื่อตรวจจับคู่เมื่อเจอวงเล็บปิด

Mental model: วงเล็บต้องปิดย้อนลำดับตามตัวเปิดล่าสุด

function isValidParentheses(text: string) {
  const stack: string[] = [];
  const pairs: Record<string, string> = { ")": "(", "]": "[", "}": "{" };

  for (const ch of text) {
    if (ch === "(" || ch === "[" || ch === "{") stack.push(ch);
    else if (pairs[ch]) {
      if (stack.pop() !== pairs[ch]) return false;
    }
  }
  return stack.length === 0;
}

Recap: balanced parentheses เป็นโจทย์ stack คลาสสิก

push ข้อมูลทั้งหมดแล้ว pop ออกเพื่อได้ลำดับกลับด้าน

Mental model: LIFO ทำให้ของท้ายกลายเป็นของหน้า

Recap: reverse คือผลลัพธ์ธรรมชาติของ stack

Monotonic stack คือ stack ที่รักษาลำดับเพิ่มหรือลดเพื่อแก้โจทย์ next greater/smaller

Mental model: pop องค์ประกอบที่ไม่สอดคล้องกับ monotonic rule

Recap: เทคนิคนี้ลด nested loop หลายโจทย์จาก O(n²) เป็น O(n)

ใช้ stack ช่วย parse ตัวเลข/operator ตามลำดับความสำคัญพื้นฐาน

Mental model: เก็บสิ่งที่ยังคำนวณไม่เสร็จไว้ใน stack

Recap: expression parsing มักใช้ stack มากกว่า 1 กอง

Infix คือ `A+B`, Prefix คือ `+AB`, Postfix คือ `AB+` ซึ่ง stack มักใช้กับ postfix evaluation

Mental model: รูปแบบนิพจน์ต่างกันที่ตำแหน่ง operator

Recap: postfix เหมาะกับการคำนวณด้วย stack แบบตรงไปตรงมา

Stack เป็น LIFO ส่วน Queue เป็น FIFO จึงเหมาะกับโจทย์คนละแบบ

Mental model: Stack = ย้อนล่าสุด, Queue = คิวตามลำดับมาก่อน

Recap: เลือกตามกฎเข้าออกของข้อมูลที่โจทย์ต้องการ

API ง่าย, operation หลัก O(1), เหมาะกับงานย้อนกลับและ parsing

Mental model: เรียบง่ายแต่พลังสูงในโจทย์ที่รูปแบบชัด

Recap: Stack ใช้งานง่ายและคาดเดาประสิทธิภาพได้ดี

เข้าถึงข้อมูลตรงกลางไม่ได้โดยตรง และใช้ได้เฉพาะปลายบนสุดเป็นหลัก

Mental model: ถ้าต้อง random access บ่อย stack ไม่ใช่ตัวเลือกที่ดี

Recap: Stack จงใจจำกัดความยืดหยุ่นเพื่อรักษากฎ LIFO

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

เช่น pop ตอน stack ว่าง, ลืมเช็ก isEmpty, เข้าใจ LIFO ผิด, และลืมเคลียร์ state ระหว่าง test case

Mental model: ก่อน pop/peek ให้เช็กความว่างทุกครั้ง

Recap: บั๊ก stack มักมาจาก edge case ตอนโครงสร้างว่าง