รูปปกบทความ

1. 🎯 ตอนที่ 9: ก้าวเข้าสู่โลกของ Trees (โครงสร้างข้อมูลแบบลำดับชั้น)

2. 📖 เปิดฉาก (The Hook)

ตลอด 8 ตอนที่ผ่านมา พี่ได้พาน้องๆ ไปลุยกับโครงสร้างข้อมูลแบบ “เส้นตรง” (Linear Data Structures) อย่าง Array, Linked List, Stack และ Queue กันมาแล้ว ซึ่งโครงสร้างพวกนี้มันก็ดีครับ ใช้งานง่าย เรียงต่อกันไปเรื่อยๆ เหมือนการต่อคิวซื้อข้าว…

แต่โลกความเป็นจริง ข้อมูลไม่ได้เรียงเป็นเส้นตรงเสมอไป! ลองนึกภาพ “แผนผังองค์กร” ที่มี CEO อยู่บนสุด แตกแขนงลงมาเป็น Manager, Team Lead และ Developer หรือระบบที่เราคุยกันอยู่ทุกวันอย่าง “ระบบโฟลเดอร์ในคอมพิวเตอร์” ถ้าน้องจะเก็บข้อมูลโฟลเดอร์ซ้อนโฟลเดอร์ด้วย Array หรือ Linked List น้องจะต้องเขียนโค้ดเช็คเงื่อนไขกันจนหัวหมุน และที่แย่คือเวลาค้นหาไฟล์ (Search) Time Complexity จะพุ่งไปเป็น $O(N)$ ทันที!

เพื่อแก้ปัญหาข้อมูลที่มีความสัมพันธ์แบบลำดับชั้น (Hierarchical Relationships) นักวิทยาศาสตร์คอมพิวเตอร์จึงได้คิดค้นโครงสร้างข้อมูลสุดเทพที่ชื่อว่า Tree (ต้นไม้) ขึ้นมาครับ วันนี้เราจะมากางแผนผังและทำความรู้จักกับคำศัพท์พื้นฐานของมันกัน!

3. 🧠 แก่นวิชา (Core Concepts)

Tree คือ โครงสร้างข้อมูลแบบ “ไม่เป็นเส้นตรง” (Non-linear Data Structure) ที่เกิดจากการนำ Node (โหนด) หลายๆ ตัวมาเชื่อมต่อกันในลักษณะที่มีลำดับชั้น แตกกิ่งก้านสาขาออกไปเรื่อยๆ (เหมือนต้นไม้ที่ถูกจับตีลังกาเอารากชี้ฟ้า)

ความแตกต่างที่ชัดเจนที่สุดระหว่าง Tree กับ Array/Linked List คือ:

  • Array / Linked List: จัดเก็บข้อมูลแบบเรียงลำดับ (Sequential) เดินหน้าไปเรื่อยๆ มีแค่ “คนก่อนหน้า” กับ “คนถัดไป”
  • Tree: จัดเก็บข้อมูลแบบลำดับชั้น (Hierarchical) มีความสัมพันธ์แบบ “พ่อแม่-ลูก” (Parent-Child) สามารถแตกแขนงไปได้หลายทิศทาง

คำศัพท์พื้นฐานในโลกของ Tree ที่ต้องจำให้ขึ้นใจ: เพื่อไม่ให้งง พี่ขอเปรียบเทียบคำศัพท์เหล่านี้กับ “ระบบโฟลเดอร์ในไดรฟ์ C:” ของเราครับ:

  • Node (โหนด): คือกล่องเก็บข้อมูลแต่ละกล่องใน Tree (เปรียบเหมือน “โฟลเดอร์” หรือ “ไฟล์” แต่ละตัว)
  • Edge (เส้นเชื่อม): คือเส้นที่ใช้เชื่อมความสัมพันธ์ระหว่าง Node (เปรียบเหมือนเส้นที่บอกว่า โฟลเดอร์นี้อยู่ในโฟลเดอร์ไหน)
  • Root (ราก): คือ Node บนสุดของ Tree ไม่มีใครเป็น Parent ของมัน มันคือจุดเริ่มต้นของทุกสิ่ง (เปรียบเหมือนไดรฟ์ C:// ที่เป็นจุดสูงสุด)
  • Parent (พ่อแม่) & Child (ลูก): Node ที่อยู่ด้านบนและชี้ลงมาเรียกว่า Parent ส่วน Node ที่ถูกชี้เรียกว่า Child (เช่น โฟลเดอร์ Windows เป็น Parent ของไฟล์ notepad.exe)
  • Leaf (ใบ): คือ Node ที่อยู่ปลายสุด “ไม่มี Child” แตกกิ่งต่อไม่ได้แล้ว (เปรียบเหมือน “ตัวไฟล์” เช่น .pdf, .exe หรือโฟลเดอร์เปล่าๆ ที่ไม่มีอะไรอยู่ข้างใน)
รูปประกอบ

4. 💻 ร่ายมนต์โค้ด (Show me the Code)

เพื่อให้เห็นภาพว่า Tree หน้าตาเป็นยังไงในระดับโค้ด เรามาลองสร้าง General Tree (ต้นไม้ทั่วไปที่ Node นึงจะมีลูกกี่คนก็ได้) เพื่อจำลองระบบไฟล์ (File System) ด้วยภาษา Python กันครับ

# สร้างพิมพ์เขียวของกล่องข้อมูล (Node) สำหรับ Tree
class TreeNode:
    def __init__(self, name):
        self.name = name           # เก็บชื่อโฟลเดอร์หรือชื่อไฟล์
        self.children = []         # สร้างลิสต์เปล่าๆ ไว้เก็บลูกๆ (Child Nodes)

    def add_child(self, child_node):
        # ฟังก์ชันสำหรับเพิ่มลูกเข้าไปในโหนดนี้ (เหมือนเอาไฟล์/โฟลเดอร์ใส่เข้าไป)
        self.children.append(child_node)

    def print_tree(self, level=0):
        # ฟังก์ชันสำหรับปริ้นท์โครงสร้าง Tree ออกมาดู โดยย่อหน้าตามระดับชั้น (Level)
        indent = "  " * level * 2
        prefix = indent + "|-- " if level > 0 else ""
        print(prefix + self.name)
        
        # ใช้ Recursion (เรียกตัวเอง) เพื่อปริ้นท์ลูกๆ ทุกตัวที่อยู่ข้างใน
        for child in self.children:
            child.print_tree(level + 1)

# ----- ลองวิชา: จำลองระบบไฟล์แบบง่ายๆ -----
# 1. สร้าง Root Node บนสุด
root = TreeNode("C://")

# 2. สร้างโฟลเดอร์ชั้นที่ 1
program_files = TreeNode("Program Files")
windows = TreeNode("Windows")

# 3. สร้างไฟล์และโฟลเดอร์ย่อย (Leaf Nodes / Internal Nodes)
notepad = TreeNode("notepad.exe")
system32 = TreeNode("System32")
vscode = TreeNode("Visual Studio")

# 4. ประกอบร่าง! (เชื่อม Edge เข้าด้วยกัน)
root.add_child(program_files)
root.add_child(windows)

windows.add_child(system32)
system32.add_child(notepad)

program_files.add_child(vscode)

# แสดงผลแผนผัง
print("โครงสร้าง Folder ของเรา:")
root.print_tree()

5. 🛡️ เคล็ดลับจากคัมภีร์ลับ (Under the Hood / Pro-Tips)

ในโลกของการทำงานจริง Tree มีบทบาทเยอะกว่าที่คุณคิดมากครับ! จากคัมภีร์ Coding Interview Patterns และ The Algorithm Design Manual ได้ระบุไว้ชัดเจนว่า Tree คือเบื้องหลังของเทคโนโลยีเปลี่ยนโลกมากมาย:

  1. ไม่มีวงวน (Acyclic): กฎเหล็กของ Tree คือ “ห้ามมี Cycle (วงวน)” เด็ดขาด! เส้น Edge จะต้องชี้จากบนลงล่างเท่านั้น (พ่อชี้ไปหาลูก) ลูกจะชี้กลับไปหาพ่อ หรือชี้ข้ามไปหาพี่น้องไม่ได้ ถ้ามีการชี้กลับไปมา โครงสร้างนั้นจะถูกเรียกว่า Graph (กราฟ) ทันทีครับ
  2. HTML / DOM: หน้าเว็บไซต์ที่น้องๆ กำลังอ่านบทความนี้อยู่ เบราว์เซอร์ก็อ่านโครงสร้าง HTML ให้อยู่ในรูปของ Tree (DOM Tree) เช่น โหนด <html> เป็น Root มีลูกคือ <head> และ <body>
  3. ทางแยกของสายย่อย: Tree ทั่วไป (General Tree) ยืดหยุ่นก็จริง แต่เพื่อการค้นหาข้อมูลที่ไวแสงระดับ $O(\log N)$ โปรแกรมเมอร์มักจะบีบข้อจำกัดให้ Tree แต่ละ Node มีลูกได้ “ไม่เกิน 2 ตัว” ซึ่งเราเรียกโครงสร้างร่างอีโวนี้ว่า “Binary Tree” และมันคือพื้นฐานของระบบ Database Indexing เลยล่ะครับ!

6. 🏁 บทสรุป (To be continued…)

Tree คือการก้าวข้ามขีดจำกัดของข้อมูลแบบเส้นตรง เพื่อให้เราสามารถจัดเก็บข้อมูลที่มีความสัมพันธ์แบบลำดับชั้น (Hierarchy) ได้อย่างเป็นธรรมชาติ ทั้งแผนผังองค์กร หรือระบบไฟล์ในคอมพิวเตอร์ การเข้าใจตำแหน่งของ Root, Node และ Leaf คือบันไดขั้นแรกที่จะพาเราไปสู่อัลกอริทึมที่ซับซ้อนขึ้น

ในตอนหน้า พี่จะพาไปเจาะลึกโครงสร้างสายพันธุ์ย่อยที่โด่งดังที่สุดของ Tree นั่นก็คือ Binary Search Tree (BST) ที่บังคับให้ลูกซ้ายต้องน้อยกว่าพ่อ และลูกขวาต้องมากกว่าพ่อเสมอ มันจะค้นหาข้อมูลได้เร็วแค่ไหน เตรียมตัวให้พร้อมแล้วพบกันครับ!

ต้องการที่ปรึกษาด้านการออกแบบ System Architecture และพัฒนาระบบซอฟต์แวร์สเกลใหญ่ให้กับองค์กรของคุณ? ทีมงาน WP Solution พร้อมให้บริการออกแบบและพัฒนาซอฟต์แวร์แบบครบวงจร ดูรายละเอียดบริการของเราได้ที่: www.wpsolution2017.com หรือพูดคุยปรึกษาเบื้องต้นได้ที่ Line: wisit.p