ในโลกแห่งการเขียนโปรแกรม การเลือกโครงสร้างข้อมูลที่เหมาะสมนับเป็นหัวใจสำคัญของการพัฒนาซอฟต์แวร์ ไม่ว่าจะเป็นแอพพลิเคชันเว็บ หรือโปรแกรมแบบเดสก์ท็อป หนึ่งในโครงสร้างข้อมูลที่มีความยืดหยุ่นสูงคือ Doubly Linked List ซึ่งเป็นการประยุกต์ใช้คอนเซปต์ของ Linked List แบบเดิม พัฒนาให้มีลิงก์ทั้งสองทิศทาง เพื่อรองรับการเข้าถึงข้อมูลด้วยความสะดวกมากขึ้น
ใน C#, Doubly Linked List จะทำงานอย่างไร? นั่นคือโครงสร้างข้อมูลที่ประกอบด้วยโหนด เเต่ละโหนดจะมีได้ข้อมูล (data) และสองลิงก์ (links); หนึ่งชี้ไปยังโหนดถัดไป (next) และอีกหนึ่งชี้กลับไปยังโหนดก่อนหน้า (previous) ซึ่งทำให้เราสามารถเดินทางผ่านรายการข้อมูลได้ทั้งสองทิศทาง
โครงสร้างนี้มีข้อดีหลากหลาย เช่น:
- การเพิ่ม (insert) หรือลบ (delete) โหนดสามารถทำได้อย่างรวดเร็ว เนื่องจากไม่จำเป็นต้องเลื่อนข้อมูลโหนดทั้งหมดเหมือนใน array
- สามารถเข้าถึงข้อมูลจากโหนดใดโหนดหนึ่งไปยังตำแหน่งอื่นๆ ได้เป็นอย่างดี เนื่องจากมีลิงก์ทั้งสองทิศทาง
อย่างไรก็ตาม ข้อเสียก็มี เช่น:
- การใช้พื้นที่จัดเก็บมากขึ้น โดยเฉพาะกับลิงก์ที่ต้องเก็บทั้งสองทิศทาง
- ความซับซ้อนของการจัดการ memory เมื่อเทียบกับโครงสร้างข้อมูลอื่นๆ ที่ง่ายกว่า
เพื่อช่วยให้ท่านเข้าใจการนำไปใช้งาน Doubly Linked List ใน C# มาดูตัวอย่างโค้ดสำหรับการ insert, insertAtFront, find, และ delete พร้อมทั้งการอธิบายการทำงาน:
public class Node {
public int data;
public Node prev;
public Node next;
public Node(int data) {
this.data = data;
this.prev = null;
this.next = null;
}
}
public class DoublyLinkedList {
private Node head = null;
// เพิ่มข้อมูลที่หัว
public void InsertFront(int data) {
Node newNode = new Node(data);
// จุดใหม่ชี้ไปยังหัวปัจจุบัน
newNode.next = head;
// ถ้าไม่ใช่การใส่โหนดที่หัวว่าง
if (head != null) {
head.prev = newNode;
}
// สั่งให้หัวชี้ไปหาโหนดใหม่
head = newNode;
}
// เพิ่มข้อมูลที่ตำแหน่งใดๆ
public void Insert(int data, Node prevNode) {
if (prevNode == null) return;
// สร้างโหนดใหม่ที่มีข้อมูล
Node newNode = new Node(data);
// ตั้งค่าลิงก์ next ให้ชี้ไปยังโหนดถัดจาก prevNode
newNode.next = prevNode.next;
// เปลี่ยน prevNode.next ให้เป็น newNode
prevNode.next = newNode;
// ตั้ง linnk prev ให้ชี้กลับมาที่ prevNode
newNode.prev = prevNode;
if(newNode.next != null)
newNode.next.prev = newNode;
}
// ค้นหาข้อมูลใน Doubly Linked List
public Node Find(int data) {
Node current = head;
while(current != null) {
if(current.data == data) return current;
current = current.next;
}
return null;
}
// ลบข้อมูลจาก Doubly Linked List
public void Delete(Node nodeToDelete) {
if (head == null || nodeToDelete == null) return;
if (head == nodeToDelete) head = nodeToDelete.next;
if (nodeToDelete.next != null) nodeToDelete.next.prev = nodeToDelete.prev;
if (nodeToDelete.prev != null) nodeToDelete.prev.next = nodeToDelete.next;
}
}
โค้ดข้างต้นนี้ประกอบไปด้วยการสร้างโครงสร้างข้อมูลในหัวข้อของเรา เริ่มต้นด้วย class Node ที่มีทั้งข้อมูล และ link ทั้งหน้าหลัง ต่อมาคือ class DoublyLinkedList ที่จัดการการทำงานของ Doubly Linked List ผ่าน method ต่างๆ ต่อจากนี้ไป ท่านจะเห็นว่า Doubly Linked List มีความยืดหยุ่นอย่างไร โดยเฉพาะในการจัดการกับข้อมูลแบบไดนามิค
ในฐานะที่เป็น EPT, เราตระหนักถึงความจำเป็นของการมีทักษะในการเขียนโค้ดระดับสูงเช่นนี้ ด้วยหลักสูตรการเรียนการสอนที่เข้มข้นและปฏิบัติการจริง เรามุ่งมั่นที่จะพัฒนานักเรียนให้มีศักยภาพพร้อมเข้าสู่อุตสาหกรรมซอฟต์แวร์ได้อย่างมืออาชีพ หากต้องการศึกษาเทคนิคต่างๆ เหล่านี้อย่างลึกซึ้ง หรือพัฒนาทักษะการเขียนโค้ดของคุณให้เข้มข้นยิ่งขึ้น ร่วมเรียนรู้ไปกับเราที่ EPT ที่นี่ เราพร้อมที่จะช่วยให้ท่านพัฒนาทักษะและพาท่านไปถึงจุดหมายในการเป็นนักพัฒนาซอฟต์แวร์อย่างที่ต้องการ
หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง
หากมีข้อผิดพลาด/ต้องการพูดคุยเพิ่มเติมเกี่ยวกับบทความนี้ กรุณาแจ้งที่ http://m.me/Expert.Programming.Tutor
085-350-7540 (DTAC)
084-88-00-255 (AIS)
026-111-618
หรือทาง EMAIL: NTPRINTF@GMAIL.COM