บทนำเกี่ยวกับการใช้รายการที่เชื่อมโยงใน Java

โครงสร้างข้อมูลใช้วิธีการที่กำหนดไว้ล่วงหน้าที่แตกต่างกันในการจัดเก็บ เรียกค้น และลบข้อมูล ซึ่งนำไปสู่การสร้างโปรแกรมที่มีประสิทธิภาพ รายการที่เชื่อมโยงเป็นโครงสร้างข้อมูลยอดนิยม ซึ่งประกอบด้วยรายการของโหนดที่เชื่อมต่อ (หรือเชื่อมโยง)

แต่คุณจะสร้างรายการเชื่อมโยงใน Java ได้อย่างไร ลองมาดูกัน

---

---

รายการที่เชื่อมโยงทำงานอย่างไร

ทุกรายการที่เชื่อมโยงเริ่มต้นด้วยโหนดพิเศษที่มักจะเรียกว่า 'หัว' ซึ่งมีหน้าที่ในการชี้ไปที่จุดเริ่มต้นของรายการตลอดเวลา ส่วนหัวมีความสำคัญเนื่องจากแต่ละโหนดในรายการที่เชื่อมโยงไม่จำเป็นต้องติดตามผู้สืบทอดทางร่างกาย (หมายความว่ารุ่นก่อนและผู้สืบทอดไม่จำเป็นต้องอยู่ติดกันทางร่างกาย)

เช่นเดียวกับโครงสร้างข้อมูลทั้งหมด รายการที่เชื่อมโยงช่วยอำนวยความสะดวกในการสร้าง การดึง การแทรก และการทำลายผ่านชุดของฟังก์ชันที่กำหนดไว้ล่วงหน้าที่นักพัฒนาสามารถใช้ได้

การสร้าง Linked List ใน Java

โปรแกรม Java ที่ออกแบบมาเพื่อสร้างและจัดการรายการที่เชื่อมโยงจะมีสามส่วนที่แตกต่างกัน คลาสโหนด คลาสรายการที่เชื่อมโยง และไดรเวอร์ แม้ว่าสามส่วนนี้จะรวมกันเป็นไฟล์เดียว แต่ก็มีหลักการออกแบบในวิทยาการคอมพิวเตอร์ที่เรียกว่า 'การแยกข้อกังวล' ที่นักพัฒนาทุกคนควรรู้

หลักการแยกข้อกังวลกำหนดให้แต่ละส่วนของรหัสที่กล่าวถึงข้อกังวลเฉพาะควรแยกออกจากกัน หลักการนี้จะช่วยให้คุณสร้างโค้ดที่สะอาดขึ้น (อ่านง่ายขึ้น) และเหมาะสำหรับการสร้างโครงสร้างข้อมูล

ขั้นตอนแรกในการสร้างรายการที่เชื่อมโยงใน Java คือการสร้างคลาสโหนด คลาสโหนดควรมีสองแอตทริบิวต์ คุณลักษณะหนึ่งจะแสดงส่วนข้อมูลของโหนด ในขณะที่แอตทริบิวต์อื่นจะแสดงส่วนที่เชื่อมโยง คลาสโหนดควรมี Constructor, getters และ setters ด้วย

---

---

ที่เกี่ยวข้อง: เรียนรู้วิธีสร้างคลาสใน Java

ตัวรับและตัวตั้งค่าจะอนุญาตให้คลาสอื่น (เช่น คลาสรายการที่เชื่อมโยง) เข้าถึงโหนดต่างๆ ภายในรายการที่เชื่อมโยง

---

---

ตัวอย่างคลาสโหนด

ด้านล่างนี้คือตัวอย่างคลาสโหนดเพื่อให้คุณเข้าใจว่าเราหมายถึงอะไร:


public class Node {
private int Data;
private Node NextNode;
//constructor
public Node() {
Data = 0;
NextNode = null;
}
//getters and setters
public int getData() {
return Data;
}
public void setData(int data) {
Data = data;
}
public Node getNextNode() {
return NextNode;
}
public void setNextNode(Node nextNode) {
NextNode = nextNode;
}
}

ในตัวอย่างนี้ แอตทริบิวต์ data จะเก็บค่าจำนวนเต็ม เมื่อคุณมีคลาสโหนดแล้ว ก็ถึงเวลาไปยังรายการที่เชื่อมโยง

ตัวอย่างรายการเชื่อมโยง

ด้านล่างนี้เป็นตัวอย่างของรายการเชื่อมโยงใน Java

public class LinkedList {
private Node Head;
//constructor
public LinkedList() {
Head = null;
}
}


โค้ดด้านบนจะสร้างคลาสรายการที่เชื่อมโยง อย่างไรก็ตาม หากไม่มีการดำเนินการต่างๆ คลาสจะถูกมองว่าเทียบเท่ากับเชลล์ว่าง โครงสร้างข้อมูลรายการที่เชื่อมโยงมีการดำเนินการหลายอย่างที่สามารถใช้เพื่อเติมข้อมูลได้:

• ใส่ด้านหน้า.
• ใส่ตรงกลาง.
• ใส่ด้านหลัง.

ที่เกี่ยวข้อง: วิธีสร้างโครงสร้างข้อมูลด้วยคลาส JavaScript ES6

การรวบรวมรายการที่เชื่อมโยงของวิธีการแทรกเป็นเหตุผลหนึ่งที่นักพัฒนาอาจเลือกใช้โครงสร้างข้อมูลนี้กับโครงสร้างข้อมูลอื่น เช่น สแต็ค (ซึ่งอนุญาตให้แทรกและลบจากด้านบนเท่านั้น)

ใช้วิธีแทรกที่ด้านหน้า

แทรกที่วิธีการด้านหน้า ตามที่ชื่อแนะนำ แทรกข้อมูลใหม่ (หรือโหนดใหม่) ที่ด้านหน้าของรายการที่เชื่อมโยง

แทรกที่ด้านหน้า Method Example

ด้านล่างนี้คือตัวอย่างวิธีการแทรกข้อมูลใหม่ที่ด้านหน้ารายการ

//insert node at front method
public void insertAtFront(int key) {
//create a new node using the node class
Node Temp = new Node();
//check if the Temp node was successfully created
//assign the data that was provides by the user to it
if(Temp != null) {
Temp.setData(key);
Temp.setNextNode(null);

//check if the head of the linked list is empty
//assign the node that was just created to the head position
if(Head == null) {
Head = Temp;
}
//if a node is already at the head position
//add the new node to it and set it as the head
else {
Temp.setNextNode(Head);
Head = Temp;
}
}
}


NS แทรกที่ด้านหน้า วิธีในตัวอย่างข้างต้นอนุญาตให้ผู้ใช้เพิ่มโหนดใหม่ในรายการเชื่อมโยงที่กำหนด

การใช้ส่วนแทรกที่ด้านหน้า ตัวอย่าง

ด้านล่างนี้คือตัวอย่างวิธีการใช้ส่วนแทรกที่ด้านหน้า

public class Driver {
//executes the program
public static void main(String[] args) {
//create a new linked list called List
LinkedList List = new LinkedList();
//add each value to the front of the linked list as a new node
List.insertAtFront(10);
List.insertAtFront(8);
List.insertAtFront(6);
List.insertAtFront(4);
List.insertAtFront(2);
}
}


NS คนขับ class (ซึ่งเป็นชื่อที่มักกำหนดให้กับคลาสที่สามารถเรียกใช้งานได้ใน Java) ใช้คลาส LinkedList เพื่อสร้างรายการเชื่อมโยงที่มีเลขคู่ห้าตัว เมื่อดูโค้ดด้านบนแล้ว จะเห็นได้ง่ายว่าตัวเลข '2' อยู่ที่ตำแหน่งส่วนหัวในรายการที่เชื่อมโยง แต่คุณจะยืนยันได้อย่างไร

ฉันไม่ได้รับคำสั่งซื้อจากอเมซอน

ใช้วิธีการแสดงโหนดทั้งหมด

วิธีแสดงโหนดทั้งหมดเป็นวิธีรายการเชื่อมโยงที่จำเป็น หากไม่มีสิ่งนี้ นักพัฒนาจะไม่สามารถเห็นโหนดในรายการที่เชื่อมโยงได้ มันเดินทางผ่านรายการที่เชื่อมโยง (เริ่มจากส่วนหัว) พิมพ์ข้อมูลที่เก็บไว้ในแต่ละโหนดที่สร้างรายการ

แสดงตัวอย่างวิธีการโหนดทั้งหมด

ด้านล่างนี้คือตัวอย่างการใช้ display all notes method ใน Java

//display all nodes method
public void displayAllNodes() {
//create a new node call Temp and assign it to the head of the linked list
//if the head has a null value then the linked list is empty
Node Temp = Head;
if (Head == null){
System.out.println('The list is empty.');
return;
}
System.out.println('The List:');

while(Temp != null) {
//print the data in each node to the console(starting from the head)
System.out.print(Temp.getData() + ' ');
Temp = Temp.getNextNode();
}
}

ตอนนี้ที่ displayAllNodes เพิ่มเมธอดลงใน .แล้ว LinkedList คลาส คุณสามารถดูรายการที่เชื่อมโยงโดยการเพิ่มโค้ดบรรทัดเดียวในคลาสไดรเวอร์

การใช้ตัวอย่างวิธีการแสดงโหนดทั้งหมด

ด้านล่างนี้ คุณจะเห็นว่าคุณจะใช้วิธีแสดงโหนดทั้งหมดอย่างไร

//print the nodes in a linked list
List.displayAllNodes();

การดำเนินการบรรทัดของรหัสด้านบนจะสร้างผลลัพธ์ต่อไปนี้ในคอนโซล:

รายการ:

2 4 6 8 10

ใช้วิธีค้นหาโหนด

จะมีบางกรณีที่ผู้ใช้ต้องการค้นหาโหนดเฉพาะในรายการที่เชื่อมโยง

ตัวอย่างเช่น จะไม่เป็นประโยชน์สำหรับธนาคารที่มีลูกค้าหลายล้านรายในการพิมพ์ลูกค้าทั้งหมดในฐานข้อมูลเมื่อพวกเขาต้องการดูรายละเอียดของลูกค้าเฉพาะรายเท่านั้น

ดังนั้น แทนที่จะใช้ displayAllNodes วิธีที่มีประสิทธิภาพมากขึ้นคือการหาโหนดเดียวที่มีข้อมูลที่จำเป็น นี่คือเหตุผลที่การค้นหาวิธีโหนดเดียวมีความสำคัญในโครงสร้างข้อมูลรายการที่เชื่อมโยง

ค้นหาตัวอย่างวิธีโหนด

ด้านล่างนี้เป็นตัวอย่างของการใช้วิธี find node

//search for a single node using a key
public boolean findNode(int key) {
//create a new node and place it at the head of the linked list
Node Temp = Head;
//while the current node is not empty
//check if its data matches the key provided by the user
while (Temp != null) {
if (Temp.getData() == key) {
System.out.println('The node is in the list');
return true;
}
//move to the next node
Temp = Temp.getNextNode();
}
//if the key was not found in the linked list
System.out.println('The node is not in the list');
return false;
}

กับ displayAllNodes วิธีที่คุณยืนยันว่า LinkedList มี 5 เลขคู่ตั้งแต่ 2 ถึง 10 The findNode ตัวอย่างข้างต้นสามารถยืนยันได้ว่าหนึ่งในจำนวนคู่นั้นเป็นตัวเลข 4 โดยเพียงแค่เรียกเมธอดในคลาสไดรเวอร์และระบุตัวเลขเป็นพารามิเตอร์

การใช้ Find Node Method Example

ด้านล่างนี้คือตัวอย่างวิธีที่คุณจะใช้วิธี find node ในทางปฏิบัติ

//check if a node is in the linked list
List.findNode(4);


รหัสด้านบนจะสร้างผลลัพธ์ต่อไปนี้ในคอนโซล:

The node is in the list

ใช้วิธีลบโหนด

เมื่อใช้ตัวอย่างธนาคารเดียวกันจากด้านบน ลูกค้าในฐานข้อมูลของธนาคารอาจต้องการปิดบัญชีของตน นี่คือจุดที่วิธีการลบโหนดจะมีประโยชน์ เป็นวิธีการเชื่อมโยงรายการที่ซับซ้อนที่สุด

วิธีการ Delete a Node จะค้นหาโหนดที่กำหนด ลบโหนดนั้น และเชื่อมโยงโหนดก่อนหน้ากับโหนดที่ตามหลังโหนดที่ถูกลบ

ลบตัวอย่างวิธีการโหนด

ด้านล่างนี้เป็นตัวอย่างของวิธีการลบโหนด

public void findAndDelete(int key) {
Node Temp = Head;
Node prev = null;
//check if the head node holds the data
//and delete it
if (Temp != null && Temp.getData() == key) {
Head = Temp.getNextNode();
return;
}
//search the other nodes in the list
//and delete it
while (Temp != null) {
if (Temp.getNextNode().getData() == key ) {
prev = Temp.getNextNode().getNextNode();
Temp.setNextNode(prev);
return;
}
Temp = Temp.getNextNode();
}
}

การใช้ตัวอย่างวิธีการลบโหนด

ด้านล่างนี้เป็นตัวอย่างของการใช้วิธี delete a node ในทางปฏิบัติ

อุปกรณ์ของคุณเชื่อมต่ออยู่แต่คุณอาจไม่สามารถเข้าถึงสิ่งใดบนเครือข่ายได้

//delete the node that holds the data 4
List.findAndDelete(4);
//print all nodes in the linked list
List.displayAllNodes();

การใช้โค้ดสองบรรทัดด้านบนในคลาส Driver ที่มีอยู่แล้วจะสร้างเอาต์พุตต่อไปนี้ในคอนโซล:

The List:
2 6 8 10

ตอนนี้คุณสามารถสร้างรายการเชื่อมโยงใน Java

หากคุณอ่านบทความบทช่วยสอนนี้จนจบ คุณจะได้เรียนรู้:

• วิธีสร้างคลาสโหนด
• วิธีสร้างคลาสรายการที่เชื่อมโยง
• วิธีเติมคลาสรายการที่เชื่อมโยงด้วยวิธีการที่กำหนดไว้ล่วงหน้า
• วิธีสร้างคลาสไดรเวอร์และใช้วิธีรายการลิงก์ต่างๆ เพื่อให้ได้ผลลัพธ์ที่ต้องการ

รายการที่เชื่อมโยงเป็นเพียงหนึ่งในโครงสร้างข้อมูลจำนวนมากที่คุณสามารถใช้เพื่อจัดเก็บ เรียกค้น และลบข้อมูล เนื่องจากคุณมีทุกสิ่งที่จำเป็นในการเริ่มต้น ทำไมไม่ลองใช้ตัวอย่างเหล่านี้ด้วยตัวคุณเองใน Java?

แบ่งปัน แบ่งปัน ทวีต อีเมล วิธีสร้างและดำเนินการกับอาร์เรย์ใน Java

เรียนจาวา? ให้อาร์เรย์จัดการข้อมูลของคุณอย่างง่ายดาย

อ่านต่อไป หัวข้อที่เกี่ยวข้อง

• การเขียนโปรแกรม
• Java
• การเขียนโปรแกรม
• เคล็ดลับการเข้ารหัส

เกี่ยวกับผู้เขียน คาเดชา คีน(21 บทความที่ตีพิมพ์)

Kadeisha Kean เป็นนักพัฒนาซอฟต์แวร์ฟูลสแตกและนักเขียนด้านเทคนิค/เทคโนโลยี เธอมีความสามารถที่ชัดเจนในการทำให้แนวคิดทางเทคโนโลยีที่ซับซ้อนที่สุดบางส่วนง่ายขึ้น การผลิตวัสดุที่สามารถเข้าใจได้ง่ายโดยสามเณรเทคโนโลยี เธอหลงใหลในการเขียน พัฒนาซอฟต์แวร์ที่น่าสนใจ และเดินทางไปทั่วโลก (ผ่านสารคดี)

เพิ่มเติมจาก Kadeisha Kean

สมัครรับจดหมายข่าวของเรา

เข้าร่วมจดหมายข่าวของเราสำหรับเคล็ดลับทางเทคนิค บทวิจารณ์ eBook ฟรี และดีลพิเศษ!

คลิกที่นี่เพื่อสมัครสมาชิก