Linked List

Linked List Operations

รวมงานพื้นฐานของ linked list ทั้ง insert, delete, update, วัดขนาด และเช็กสถานะว่างแบบทีละขั้น

ภาพรวม Operations บน Linked List

การจัดการ linked list มีชุด operations พื้นฐานที่คุณต้องทำเป็น: Insert (เพิ่มที่หัว, ท้าย, กลาง), Delete (ลบที่หัว, ท้าย, กลาง), Search (ค้นหา), Update (อัปเดตค่า), isEmpty (ตรวจว่าว่าง), และ Size (หาขนาด) — มาดูวิธีการทำแต่ละ operation อย่างละเอียด

**Prepend** (เพิ่มที่หัว) — สร้าง node ใหม่ ชี้ next ไป head เดิม แล้วเลื่อน head → O(1)
**Append** (เพิ่มที่ท้าย) — ถ้ามี tail: ชี้ next ของ tail ไป node ใหม่ แล้วเลื่อน tail → O(1); ถ้าไม่มี tail: เดินจาก head จนสุด → O(n)
**Insert at Index** (แทรกตรงกลาง) — เดินหา node ก่อนตำแหน่งแทรก (O(n)) แล้วปรับ pointer → O(1) ที่ตัว node
**Delete** (ลบ) — ใช้วิธีเดียวกัน: หา node ก่อนตำแหน่งลบ แล้วเปลี่ยน next ให้ข้าม node นั้น → O(n) เพื่อหา + O(1) เพื่อลบ
**Search & Update** — linear search หาค่า (O(n)) แล้วแก้ value ของ node (O(1))

Prepend — เพิ่ม node ใหม่ที่หัวรายการ O(1)

Prepend คือการเพิ่ม node ใหม่ไว้ข้างหน้าสุดของ list — เป็น operation ที่เร็วที่สุดของ linked list เพราะใช้เวลา O(1) ไม่ต้องเดินหาเลย

Prepend — เพิ่มที่หัว O(1)JS

สร้าง node ใหม่ ชี้ next ไป head เดิม เลื่อน head — จบใน 1 step

function prepend(head, tail, value) {
  const node = { value, next: head };

  if (tail === null) {
    return { head: node, tail: node };
  }

  return { head: node, tail };
}

// Example
let head = null;
let tail = null;

const result1 = prepend(head, tail, 30);
head = result1.head; tail = result1.tail; // [30]
const result2 = prepend(head, tail, 20);
head = result2.head; tail = result2.tail; // [20 → 30]
const result3 = prepend(head, tail, 10);
head = result3.head; tail = result3.tail; // [10 → 20 → 30]

ข้อควรระวัง: ถ้า list ว่าง (head เป็น null) เราต้องตั้ง tail ให้ชี้ node ใหม่ด้วย — เพราะ node ใหม่เป็นทั้ง head และ tail ของ list ตัวเดียว

Append — เพิ่ม node ใหม่ที่ท้ายรายการ

Append คือการเพิ่ม node ใหม่ที่ท้ายสุดของ list — ความเร็วขึ้นอยู่กับว่ามี tail reference หรือไม่

Append — เพิ่มที่ท้าย O(1) มี tail / O(n) ไม่มี tailJS

ความต่างมีนัยสำคัญ — ควรเก็บ tail ไว้เสมอถ้างานเน้น append

// เวอร์ชันมี tail — O(1)
function appendWithTail(head, tail, value) {
  const node = { value, next: null };

  if (head === null) {
    return { head: node, tail: node };
  }

  tail.next = node;
  return { head, tail: node };
}

// เวอร์ชันไม่มี tail — O(n) ต้องเดินจาก head
function appendNoTail(head, value) {
  const node = { value, next: null };

  if (head === null) return node;

  let current = head;
  while (current.next !== null) {
    current = current.next;
  }
  current.next = node;

  return head;
}

กรณี	Time Complexity	เหตุผล
มี tail reference	O(1)	เข้าถึง tail โดยตรง — ไม่ต้องเดิน
ไม่มี tail reference	O(n)	ต้องเดินจาก head ผ่านทุก node จนสุด
List ว่าง (head = null)	O(1)	ไม่ต้องเดิน — node ใหม่เป็นทั้ง head และ tail
มี tail + doubly linked list	O(1)	เหมือนมี tail ใน singly + เพิ่ม prev ได้ทันที

Insert — แทรก node ตรงกลางที่ index ที่ต้องการ

การแทรก node ที่ตำแหน่งกลาง list ประกอบด้วย 2 ขั้นตอน: (1) เดินหา node ก่อนตำแหน่งแทรก → O(n) และ (2) ปรับ next pointer → O(1) — โดยรวมใช้เวลา O(n)

Insert at Index — แทรกที่ตำแหน่งกลาง O(n)JS

เดิน i-1 ก้าวหา node ก่อนจุดแทรก แล้วสลับ pointer

function insertAt(head, index, value) {
  const node = { value, next: null };

  // แทรกที่หัว (index 0)
  if (index === 0) {
    node.next = head;
    return node;
  }

  // เดินหาตำแหน่งก่อนจุดแทรก
  let current = head;
  for (let i = 0; i < index - 1; i += 1) {
    if (current === null) return head; // index เกินขนาด
    current = current.next;
  }

  if (current === null) return head;

  // แทรก: node.next = current.next, current.next = node
  node.next = current.next;
  current.next = node;

  return head;
}

**Step 1:** สร้าง node ใหม่ `{ value, next: null }`
**Step 2:** ถ้า index = 0 → prepend (node.next = head)
**Step 3:** วนลูป i-1 รอบ หาตัวแปร current ชี้ไปที่ node ก่อนตำแหน่งแทรก
**Step 4:** `node.next = current.next` — ให้ node ใหม่ชี้ไป node ถัดไปก่อน (สำคัญ!)
**Step 5:** `current.next = node` — ให้ node ปัจจุบันชี้ไป node ใหม่ แทรกตรงกลางสำเร็จ

Delete — ลบ node ที่หัว O(1)

Delete head คือการลบ node แรกสุด — ใช้เวลา O(1) โดยการเลื่อน head ไป next ของ head เดิม (node ที่ถูกลบจะถูก garbage collector จัดการเอง)

Delete Head — ลบหัว O(1)JS

head = head.next — จบ แค่นี้ก็ลบ node แรกออกแล้ว

function deleteHead(head, tail) {
  if (head === null) return { head: null, tail: null };

  const newHead = head.next;

  // ถ้า list เหลือ node เดียว → tail ก็เป็น null ด้วย
  if (newHead === null) {
    return { head: null, tail: null };
  }

  // รีไวร์ prev (ถ้าเป็น doubly)
  if (newHead.prev) newHead.prev = null;

  return { head: newHead, tail };
}

Delete — ลบ node ที่ท้าย O(n)

การลบ tail ใน singly linked list ต้องเดินจาก head จนถึง node ก่อน tail (O(n)) เพราะเราต้อง set `next` ของ node นั้นเป็น `null` — ไม่สามารถเข้าถึง node ก่อนหน้าโดยตรงได้ (ต่างจาก doubly linked list ที่ใช้ `tail.prev` → O(1))

Delete Tail ใน Singly List — O(n)JS

ต้องเดินหา node ก่อน tail เพื่อตั้ง next = null

function deleteTail(head, tail) {
  if (head === null) return { head: null, tail: null };
  if (head.next === null) return { head: null, tail: null };

  let current = head;
  while (current.next !== tail) {
    current = current.next;
  }

  current.next = null;
  return { head, tail: current };
}

**Step 1:** เช็กว่ามี 0 หรือ 1 node — ถ้ามี 0 node คืน head/tail null; ถ้ามี 1 node คืน head/tail null ทั้งคู่
**Step 2:** วนลูปหา node ก่อน tail — current.next !== tail (หรือ current.next.next !== null ก็เป็นวิธีเดียวกัน)
**Step 3:** `current.next = null` — ตัด tail ทิ้ง
**Step 4 (ถ้ามี):** อัปเดต `tail = current` — ตอนนี้ current กลายเป็น tail ใหม่

Delete — ลบ node ตรงกลาง O(n)

การลบ node ที่ตำแหน่งใด ๆ ใน list: เดินหา node ก่อนตำแหน่งลบ (O(n)) แล้วรีไวร์ next ให้ข้าม node นั้น (O(1)) — โดยรวมใช้ O(n)

Delete at Index — ลบตรงกลาง O(n)JS

เดิน i-1 ก้าว → current.next = current.next.next เพื่อข้าม

function deleteAt(head, tail, index) {
  if (head === null) return { head: null, tail: null };

  // ลบ head
  if (index === 0) {
    const newHead = head.next;
    if (newHead && newHead.prev) newHead.prev = null;
    const newTail = newHead === null ? null : tail;
    return { head: newHead, tail: newTail };
  }

  // เดินหา node ก่อนตำแหน่งลบ
  let current = head;
  for (let i = 0; i < index - 1; i += 1) {
    if (current.next === null) return { head, tail };
    current = current.next;
  }

  if (current.next === null) return { head, tail };

  // ลบ: ข้าม node เป้าหมาย
  const deleted = current.next;
  current.next = deleted.next;

  // ถ้าลบ tail → อัปเดต tail
  const newTail = current.next === null ? current : tail;

  return { head, tail: newTail };
}

ค้นหา (Find) และอัปเดต (Update) — แก้ไขค่าใน node โดยไม่เปลี่ยนโครงสร้าง

การค้นหาและอัปเดตค่าใน linked list ใช้หลักการเดียวกับ array — ไล่หาจนเจอ node เป้าหมาย แล้วแก้ไข `value` โดยตรง ไม่ต้องจัดการ pointer

Find & Update — ค้นหาค่าและอัปเดตJS

Search = O(n), Update (เมื่อรู้ตำแหน่งแล้ว) = O(n) เพื่อหา + O(1) เพื่อแก้

function find(head, target) {
  let current = head;
  let index = 0;

  while (current !== null) {
    if (current.value === target) return index;
    current = current.next;
    index += 1;
  }

  return -1;
}

function updateAt(head, index, newValue) {
  let current = head;

  for (let i = 0; i < index && current !== null; i += 1) {
    current = current.next;
  }

  if (current === null) return false;

  current.value = newValue;
  return true;
}

const head = makeList([10, 20, 30]);
console.log(find(head, 20));      // 1
console.log(updateAt(head, 1, 99)); // true
// head กลายเป็น 10 → 99 → 30

ตรวจลิสต์ว่าง (isEmpty) และหาขนาด (Size)

isEmpty (O(1)), Size (O(n) หรือ O(1) หากเก็บ counter)JS

ตรวจ head === null = O(1); นับ size แบบเดิน = O(n); เก็บ counter ในคลาส = O(1) แต่ต้องอัปเดตทุก operation

// isEmpty — ตรวจดูที่ head ทันที O(1)
function isEmpty(head) {
  return head === null;
}

// size (เดินนับ) — O(n) เพราะต้องนับทุก node
function sizeByWalk(head) {
  let count = 0;
  let current = head;

  while (current !== null) {
    count += 1;
    current = current.next;
  }

  return count;
}

// size (เก็บ counter) — O(1) แต่ต้องอัปเดต counter ทุก insert/delete
class TrackedList {
  constructor() {
    this.head = null;
    this.tail = null;
    this._size = 0;
  }

  prepend(value) {
    const node = { value, next: this.head };
    this.head = node;
    if (!this.tail) this.tail = node;
    this._size += 1;
  }

  get size() {
    return this._size;
  }
}

วิธี	Time (อ่าน)	Time (ดูแล)	เหมาะกับ
เดินนับทุกครั้ง	O(n)	O(0) — ไม่ต้องดูแล	list ที่ size เปลี่ยนน้อยแต่ query บ่อย
เก็บ counter ในคลาส	O(1)	O(1) — อัปเดตทุก insert/delete	list ที่ query size บ่อยมาก
isEmpty (head === null)	O(1)	O(0)	ใช้ได้เสมอ ไม่เปลี่ยน complexity

ดูโค้ดทำงานทีละขั้น — Insert & Delete Flow

ลองลงมือ — ฝึก Insert & Delete

ถึงเวลาลงมือ implement operations บน linked list — เริ่มจากเขียน insert และ delete function

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

Linked List Operations — Key Rules

หัวใจสำคัญของทุก operation บน linked list

กฎข้อ 1

Prepend = O(1) — เร็วสุด, Append มี tail = O(1)

สอง operation พื้นฐานที่ linked list ทำได้ดีกว่า array — ใช้เมื่อ workload เน้น insert/delete ที่ขอบรายการ

กฎข้อ 2

Insert/Delete ตรงกลาง = O(n) เพราะต้องเดินหาตำแหน่ง

การเดินหาตำแหน่งคือต้นทุนหลัก — operation ที่ตัว node เองใช้ O(1) แต่การหา node ใช้ O(n) ทำให้โดยรวมยังเป็น O(n)

กฎข้อ 3

ลำดับการเปลี่ยน pointer สำคัญมาก — ระวัง lost reference

เวลา insert: ต้องชี้ next ของ node ใหม่ไปยัง node ถัดไปก่อน แล้วค่อยเปลี่ยน next ของ current — ถ้าทำกลับกันคุณจะสูญเสีย reference ไป node ถัดไปทันที

ระวัง 1

อย่าลืมเช็ก null — head, current.next, current.next.next

ทุกครั้งที่คุณเปลี่ยน next ต้องแน่ใจว่าค่าที่กำลังเปลี่ยนมีอยู่จริง — การใช้ .next บน null ทำให้เกิด TypeError ทันที

ระวัง 2

อย่าลืมอัปเดต tail เมื่อลบหรือเพิ่ม

ถ้าใช้คลาสเก็บ tail ไว้ ต้องอัปเดต tail ให้ชี้ถูกต้องหลัง insert/delete — ถ้าไม่ทำ tail อาจชี้ไป node ที่ถูกลบไปแล้วหรือไม่ได้อัปเดต

Linked List

Linked List Operations

ภาพรวม Operations บน Linked List

**Prepend** (เพิ่มที่หัว) — สร้าง node ใหม่ ชี้ next ไป head เดิม แล้วเลื่อน head → O(1)
**Append** (เพิ่มที่ท้าย) — ถ้ามี tail: ชี้ next ของ tail ไป node ใหม่ แล้วเลื่อน tail → O(1); ถ้าไม่มี tail: เดินจาก head จนสุด → O(n)
**Insert at Index** (แทรกตรงกลาง) — เดินหา node ก่อนตำแหน่งแทรก (O(n)) แล้วปรับ pointer → O(1) ที่ตัว node
**Delete** (ลบ) — ใช้วิธีเดียวกัน: หา node ก่อนตำแหน่งลบ แล้วเปลี่ยน next ให้ข้าม node นั้น → O(n) เพื่อหา + O(1) เพื่อลบ
**Search & Update** — linear search หาค่า (O(n)) แล้วแก้ value ของ node (O(1))

Prepend — เพิ่ม node ใหม่ที่หัวรายการ O(1)

Prepend — เพิ่มที่หัว O(1)JS

สร้าง node ใหม่ ชี้ next ไป head เดิม เลื่อน head — จบใน 1 step

function prepend(head, tail, value) {
  const node = { value, next: head };

  if (tail === null) {
    return { head: node, tail: node };
  }

  return { head: node, tail };
}

// Example
let head = null;
let tail = null;

const result1 = prepend(head, tail, 30);
head = result1.head; tail = result1.tail; // [30]
const result2 = prepend(head, tail, 20);
head = result2.head; tail = result2.tail; // [20 → 30]
const result3 = prepend(head, tail, 10);
head = result3.head; tail = result3.tail; // [10 → 20 → 30]

Append — เพิ่ม node ใหม่ที่ท้ายรายการ

Append — เพิ่มที่ท้าย O(1) มี tail / O(n) ไม่มี tailJS

ความต่างมีนัยสำคัญ — ควรเก็บ tail ไว้เสมอถ้างานเน้น append

// เวอร์ชันมี tail — O(1)
function appendWithTail(head, tail, value) {
  const node = { value, next: null };

  if (head === null) {
    return { head: node, tail: node };
  }

  tail.next = node;
  return { head, tail: node };
}

// เวอร์ชันไม่มี tail — O(n) ต้องเดินจาก head
function appendNoTail(head, value) {
  const node = { value, next: null };

  if (head === null) return node;

  let current = head;
  while (current.next !== null) {
    current = current.next;
  }
  current.next = node;

  return head;
}

กรณี	Time Complexity	เหตุผล
มี tail reference	O(1)	เข้าถึง tail โดยตรง — ไม่ต้องเดิน
ไม่มี tail reference	O(n)	ต้องเดินจาก head ผ่านทุก node จนสุด
List ว่าง (head = null)	O(1)	ไม่ต้องเดิน — node ใหม่เป็นทั้ง head และ tail
มี tail + doubly linked list	O(1)	เหมือนมี tail ใน singly + เพิ่ม prev ได้ทันที

Insert — แทรก node ตรงกลางที่ index ที่ต้องการ

Insert at Index — แทรกที่ตำแหน่งกลาง O(n)JS

เดิน i-1 ก้าวหา node ก่อนจุดแทรก แล้วสลับ pointer

function insertAt(head, index, value) {
  const node = { value, next: null };

  // แทรกที่หัว (index 0)
  if (index === 0) {
    node.next = head;
    return node;
  }

  // เดินหาตำแหน่งก่อนจุดแทรก
  let current = head;
  for (let i = 0; i < index - 1; i += 1) {
    if (current === null) return head; // index เกินขนาด
    current = current.next;
  }

  if (current === null) return head;

  // แทรก: node.next = current.next, current.next = node
  node.next = current.next;
  current.next = node;

  return head;
}

**Step 1:** สร้าง node ใหม่ `{ value, next: null }`
**Step 2:** ถ้า index = 0 → prepend (node.next = head)
**Step 3:** วนลูป i-1 รอบ หาตัวแปร current ชี้ไปที่ node ก่อนตำแหน่งแทรก
**Step 4:** `node.next = current.next` — ให้ node ใหม่ชี้ไป node ถัดไปก่อน (สำคัญ!)
**Step 5:** `current.next = node` — ให้ node ปัจจุบันชี้ไป node ใหม่ แทรกตรงกลางสำเร็จ

Delete — ลบ node ที่หัว O(1)

Delete Head — ลบหัว O(1)JS

head = head.next — จบ แค่นี้ก็ลบ node แรกออกแล้ว

function deleteHead(head, tail) {
  if (head === null) return { head: null, tail: null };

  const newHead = head.next;

  // ถ้า list เหลือ node เดียว → tail ก็เป็น null ด้วย
  if (newHead === null) {
    return { head: null, tail: null };
  }

  // รีไวร์ prev (ถ้าเป็น doubly)
  if (newHead.prev) newHead.prev = null;

  return { head: newHead, tail };
}

Delete — ลบ node ที่ท้าย O(n)

Delete Tail ใน Singly List — O(n)JS

ต้องเดินหา node ก่อน tail เพื่อตั้ง next = null

function deleteTail(head, tail) {
  if (head === null) return { head: null, tail: null };
  if (head.next === null) return { head: null, tail: null };

  let current = head;
  while (current.next !== tail) {
    current = current.next;
  }

  current.next = null;
  return { head, tail: current };
}

**Step 1:** เช็กว่ามี 0 หรือ 1 node — ถ้ามี 0 node คืน head/tail null; ถ้ามี 1 node คืน head/tail null ทั้งคู่
**Step 2:** วนลูปหา node ก่อน tail — current.next !== tail (หรือ current.next.next !== null ก็เป็นวิธีเดียวกัน)
**Step 3:** `current.next = null` — ตัด tail ทิ้ง
**Step 4 (ถ้ามี):** อัปเดต `tail = current` — ตอนนี้ current กลายเป็น tail ใหม่

Delete — ลบ node ตรงกลาง O(n)

Delete at Index — ลบตรงกลาง O(n)JS

เดิน i-1 ก้าว → current.next = current.next.next เพื่อข้าม

function deleteAt(head, tail, index) {
  if (head === null) return { head: null, tail: null };

  // ลบ head
  if (index === 0) {
    const newHead = head.next;
    if (newHead && newHead.prev) newHead.prev = null;
    const newTail = newHead === null ? null : tail;
    return { head: newHead, tail: newTail };
  }

  // เดินหา node ก่อนตำแหน่งลบ
  let current = head;
  for (let i = 0; i < index - 1; i += 1) {
    if (current.next === null) return { head, tail };
    current = current.next;
  }

  if (current.next === null) return { head, tail };

  // ลบ: ข้าม node เป้าหมาย
  const deleted = current.next;
  current.next = deleted.next;

  // ถ้าลบ tail → อัปเดต tail
  const newTail = current.next === null ? current : tail;

  return { head, tail: newTail };
}

ค้นหา (Find) และอัปเดต (Update) — แก้ไขค่าใน node โดยไม่เปลี่ยนโครงสร้าง

Find & Update — ค้นหาค่าและอัปเดตJS

Search = O(n), Update (เมื่อรู้ตำแหน่งแล้ว) = O(n) เพื่อหา + O(1) เพื่อแก้

function find(head, target) {
  let current = head;
  let index = 0;

  while (current !== null) {
    if (current.value === target) return index;
    current = current.next;
    index += 1;
  }

  return -1;
}

function updateAt(head, index, newValue) {
  let current = head;

  for (let i = 0; i < index && current !== null; i += 1) {
    current = current.next;
  }

  if (current === null) return false;

  current.value = newValue;
  return true;
}

const head = makeList([10, 20, 30]);
console.log(find(head, 20));      // 1
console.log(updateAt(head, 1, 99)); // true
// head กลายเป็น 10 → 99 → 30

ตรวจลิสต์ว่าง (isEmpty) และหาขนาด (Size)

isEmpty (O(1)), Size (O(n) หรือ O(1) หากเก็บ counter)JS

ตรวจ head === null = O(1); นับ size แบบเดิน = O(n); เก็บ counter ในคลาส = O(1) แต่ต้องอัปเดตทุก operation

// isEmpty — ตรวจดูที่ head ทันที O(1)
function isEmpty(head) {
  return head === null;
}

// size (เดินนับ) — O(n) เพราะต้องนับทุก node
function sizeByWalk(head) {
  let count = 0;
  let current = head;

  while (current !== null) {
    count += 1;
    current = current.next;
  }

  return count;
}

// size (เก็บ counter) — O(1) แต่ต้องอัปเดต counter ทุก insert/delete
class TrackedList {
  constructor() {
    this.head = null;
    this.tail = null;
    this._size = 0;
  }

  prepend(value) {
    const node = { value, next: this.head };
    this.head = node;
    if (!this.tail) this.tail = node;
    this._size += 1;
  }

  get size() {
    return this._size;
  }
}

วิธี	Time (อ่าน)	Time (ดูแล)	เหมาะกับ
เดินนับทุกครั้ง	O(n)	O(0) — ไม่ต้องดูแล	list ที่ size เปลี่ยนน้อยแต่ query บ่อย
เก็บ counter ในคลาส	O(1)	O(1) — อัปเดตทุก insert/delete	list ที่ query size บ่อยมาก
isEmpty (head === null)	O(1)	O(0)	ใช้ได้เสมอ ไม่เปลี่ยน complexity

ดูโค้ดทำงานทีละขั้น — Insert & Delete Flow

ลองลงมือ — ฝึก Insert & Delete

ถึงเวลาลงมือ implement operations บน linked list — เริ่มจากเขียน insert และ delete function

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

Linked List Operations — Key Rules

หัวใจสำคัญของทุก operation บน linked list

กฎข้อ 1

Prepend = O(1) — เร็วสุด, Append มี tail = O(1)

กฎข้อ 2

Insert/Delete ตรงกลาง = O(n) เพราะต้องเดินหาตำแหน่ง

กฎข้อ 3

ลำดับการเปลี่ยน pointer สำคัญมาก — ระวัง lost reference

ระวัง 1

อย่าลืมเช็ก null — head, current.next, current.next.next

ระวัง 2

Data Structures & Algorithms

Linked List Operations

ภาพรวม Operations บน Linked List

Prepend — เพิ่ม node ใหม่ที่หัวรายการ O(1)

Append — เพิ่ม node ใหม่ที่ท้ายรายการ

Insert — แทรก node ตรงกลางที่ index ที่ต้องการ

Delete — ลบ node ที่หัว O(1)

Delete — ลบ node ที่ท้าย O(n)

Delete — ลบ node ตรงกลาง O(n)

ค้นหา (Find) และอัปเดต (Update) — แก้ไขค่าใน node โดยไม่เปลี่ยนโครงสร้าง

ตรวจลิสต์ว่าง (isEmpty) และหาขนาด (Size)

ดูโค้ดทำงานทีละขั้น — Insert & Delete Flow

ลองลงมือ — ฝึก Insert & Delete

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

Linked List Operations — Key Rules

Prepend = O(1) — เร็วสุด, Append มี tail = O(1)

Insert/Delete ตรงกลาง = O(n) เพราะต้องเดินหาตำแหน่ง

ลำดับการเปลี่ยน pointer สำคัญมาก — ระวัง lost reference

อย่าลืมเช็ก null — head, current.next, current.next.next

อย่าลืมอัปเดต tail เมื่อลบหรือเพิ่ม

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

Loading

Data Structures & Algorithms

Linked List Operations

ภาพรวม Operations บน Linked List

Prepend — เพิ่ม node ใหม่ที่หัวรายการ O(1)

Append — เพิ่ม node ใหม่ที่ท้ายรายการ

Insert — แทรก node ตรงกลางที่ index ที่ต้องการ

Delete — ลบ node ที่หัว O(1)

Delete — ลบ node ที่ท้าย O(n)

Delete — ลบ node ตรงกลาง O(n)

ค้นหา (Find) และอัปเดต (Update) — แก้ไขค่าใน node โดยไม่เปลี่ยนโครงสร้าง

ตรวจลิสต์ว่าง (isEmpty) และหาขนาด (Size)

ดูโค้ดทำงานทีละขั้น — Insert & Delete Flow

ลองลงมือ — ฝึก Insert & Delete

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

Linked List Operations — Key Rules

Prepend = O(1) — เร็วสุด, Append มี tail = O(1)

Insert/Delete ตรงกลาง = O(n) เพราะต้องเดินหาตำแหน่ง

ลำดับการเปลี่ยน pointer สำคัญมาก — ระวัง lost reference

อย่าลืมเช็ก null — head, current.next, current.next.next

อย่าลืมอัปเดต tail เมื่อลบหรือเพิ่ม

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