Isang Panimula sa Paggamit ng Mga Naka-link na Listahan sa Java

Isang Panimula sa Paggamit ng Mga Naka-link na Listahan sa Java

Gumagamit ang isang istraktura ng data ng iba't ibang mga paunang natukoy na pamamaraan upang maiimbak, makuha, at matanggal ang data na kung saan ay magtatapos sa paglikha ng mga mahusay na programa. Ang isang naka-link na listahan ay isang tanyag na istraktura ng data, na binubuo ng isang listahan ng mga node na konektado (o naka-link).





Ngunit paano ka makakalikha ng isang naka-link na listahan sa Java? Tignan natin.



Paano gumagana ang isang Listahang Nakaugnay?

Ang bawat listahan ng naka-link ay nagsisimula sa isang espesyal na node na madalas na tinukoy bilang 'ulo', na may responsibilidad na ituro ang simula ng listahan sa lahat ng oras. Mahalaga ang ulo sapagkat ang bawat node sa isang naka-link na listahan ay hindi kailangang sundin ang kahalili nito nang pisikal (nangangahulugang ang isang hinalinhan at isang kahalili ay hindi kailangang maging katabi ng pisikal).





Tulad ng bawat istraktura ng data, pinapabilis ng listahan ng naka-link ang paglikha, pagkuha, pagpasok, at pagkawasak sa pamamagitan ng isang hanay ng mga paunang natukoy na pag-andar na maaaring magamit ng anumang developer.

Lumilikha ng isang Naka-link na Listahan sa Java

Ang isang programang Java na idinisenyo upang lumikha at manipulahin ang mga naka-link na listahan ay magkakaroon ng tatlong natatanging mga seksyon; ang klase ng node, klase ng naka-link na listahan, at ang driver. Bagaman ang tatlong seksyon na ito ay maaaring pagsasama sa isang file, mayroong isang prinsipyo ng disenyo sa agham ng computer na kilala bilang 'paghihiwalay ng mga alalahanin' na dapat malaman ng bawat developer.



Ang paghihiwalay ng mga prinsipyo ng pag-aalala ay nagdidikta na ang bawat seksyon ng code na tumutugon sa isang tukoy na pag-aalala ay dapat na paghiwalayin. Tutulungan ka ng prinsipyong ito na lumikha ng mas malinis (mas nababasa) na code at mainam para sa paglikha ng mga istruktura ng data.

Ang unang hakbang sa paglikha ng isang naka-link na listahan sa Java ay upang lumikha ng isang node class. Ang isang klase sa node ay dapat magkaroon ng dalawang mga katangian; ang isa sa mga katangian ay kumakatawan sa bahagi ng data ng node, habang ang iba pang katangian ay kumakatawan sa naka-link na bahagi. Ang isang klase sa node ay dapat ding magkaroon ng isang tagapagbuo, getter, at setter.



Kaugnay: Alamin Kung Paano Lumikha ng Mga Klase sa Java

Papayagan ng mga getter at setter ang iba pang mga klase (tulad ng naka-link na klase ng listahan) na ma-access ang iba't ibang mga node sa loob ng naka-link na listahan.



Halimbawa ng Klase ng Node

Nasa ibaba ang isang halimbawa ng klase ng node para sa iyo upang makakuha ng ideya kung ano ang ibig sabihin namin:


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;
}
}

Sa halimbawang ito, ang katangian ng data ay mag-iimbak ng mga halaga ng integer. Ngayon na mayroon ka ng klase ng node, oras na upang magpatuloy sa naka-link na listahan.

Halimbawa ng Naka-link na Lista

Nasa ibaba ang isang halimbawa ng isang naka-link na listahan sa Java.

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

Ang code sa itaas ay lilikha ng isang naka-link na klase ng listahan, gayunpaman, nang walang iba't ibang mga operasyon nito, makikita ang klase bilang katumbas ng isang walang laman na shell. Ang istraktura ng data ng naka-link na listahan ay may maraming mga operasyon na maaaring magamit upang mapunan ito:

  • Isingit sa harap.
  • Isingit sa gitna.
  • Ipasok sa likod.

Kaugnay: Paano Bumuo ng Mga Istraktura ng Data Sa Mga Klase ng JavaScript ES6

Ang koleksyon ng naka-link na listahan ng mga pamamaraan ng pagpapasok ay isang dahilan kung bakit maaaring piliin ng isang developer na gamitin ang istraktura ng data na ito sa isa pang istraktura ng data tulad ng mga stack (na pinapayagan lamang ang pagpapasok at pagtanggal mula sa itaas).

Gamit ang Ipasok sa Paunang Pamamaraan

Ang insert sa harap na pamamaraan, tulad ng ipinahihiwatig ng pangalan, ay nagsisingit ng bagong data (o mga bagong node) sa harap ng naka-link na listahan.

Ipasok sa Halimbawa ng Harap na Paraan

Nasa ibaba ang isang halimbawa kung paano mo isisingit ang bagong data sa harap ng iyong listahan.

//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;
}
}
}

Ang insertAtFront Ang pamamaraan sa halimbawa sa itaas ay nagbibigay-daan sa isang gumagamit na magdagdag ng mga bagong node sa isang ibinigay na listahan ng naka-link.

Paglalapat ng Ipasok sa Pangunahing Halimbawa

Nasa ibaba ang isang halimbawa ng kung paano mo mailalapat ang insert sa harap.

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);
}
}

Ang Driver klase (na kung saan ay ang pangalan na madalas na nakatalaga sa maipapatupad na klase sa Java), gumagamit ng klase ng LinkedList upang lumikha ng isang naka-link na listahan ng limang pantay na mga numero. Ang pagtingin sa code sa itaas ay dapat na madaling makita na ang numero na '2' ay nasa posisyon ng ulo sa naka-link na listahan. Ngunit paano mo ito makukumpirma?

kailan lalabas ang ps4

Gamit ang Display All Nodes na Pamamaraan

Ang paraan ng pagpapakita ng lahat ng mga node ay isang mahalagang pamamaraan ng listahan ng naka-link. Kung wala ito, hindi makikita ng isang developer ang mga node sa isang naka-link na listahan. Naglalakbay ito sa pamamagitan ng naka-link na listahan (simula sa ulo) na nagpi-print ng data na nakaimbak sa bawat node na bumubuo sa listahan.

Ipakita ang Lahat ng Halimbawa ng Paraan ng Mga Node

Nasa ibaba ang isang halimbawa ng paggamit ng ipakita ang lahat ng mga paraan ng tala sa 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();
}
}

Ngayon na ang displayAllNodes ang pamamaraan ay naidagdag sa LinkedList klase maaari mong tingnan ang naka-link na listahan sa pamamagitan ng pagdaragdag ng isang solong linya ng code sa klase ng driver.

Gamit ang Halimbawa ng Pamamaraan ng Ipakita ang Lahat ng Node

Sa ibaba, makikita mo kung paano mo gagamitin ang pagpapakita ng lahat ng pamamaraan ng mga node.

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

Ang pagpapatupad ng linya ng code sa itaas ay makakagawa ng sumusunod na output sa console:

Ang listahan:

2 4 6 8 10

Gamit ang Paraan ng Find Node

Magkakaroon ng mga pagkakataong nais ng isang gumagamit na makahanap ng isang tukoy na node sa isang naka-link na listahan.

Halimbawa, hindi magiging praktikal para sa isang bangko na may milyun-milyong mga customer upang mai-print ang lahat ng mga customer 'sa kanilang database kapag kailangan lamang nilang makita ang mga detalye ng isang tukoy na customer.

Samakatuwid, sa halip na gamitin ang displayAllNodes paraan, isang mas mahusay na pamamaraan ay upang mahanap ang solong node na naglalaman ng kinakailangang data. Ito ang dahilan kung bakit ang paghahanap para sa isang solong pamamaraan ng node ay mahalaga sa naka-link na istraktura ng data ng listahan.

Maghanap ng Halimbawa ng Paraan ng Node

Nasa ibaba ang isang halimbawa ng paggamit ng pamamaraan ng 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;
}

Kasama ang displayAllNodes paraan, nakumpirma mo na ang LinkedList naglalaman ng 5 pantay na mga numero mula 2 hanggang 10. Ang findNode Ang halimbawa sa itaas ay maaaring kumpirmahin kung ang isa sa mga pantay na numero ay ang bilang ng 4 sa pamamagitan lamang ng pagtawag sa pamamaraan sa klase ng driver at pagbibigay ng bilang bilang isang parameter.

Gamit ang Halimbawang Paraan ng Find Node

Nasa ibaba ang isang halimbawa ng kung paano mo gagamitin ang pamamaraan ng find node sa pagsasanay.

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

Ang code sa itaas ay gagawa ng sumusunod na output sa console:

The node is in the list

Gamit ang Tanggalin ang isang Paraan ng Node

Gamit ang parehong halimbawa sa bangko mula sa itaas, maaaring hilingin ng isang customer sa database ng bangko na isara ang kanilang account. Dito ay magiging kapaki-pakinabang ang pagtanggal ng isang paraan ng node. Ito ang pinaka-kumplikadong paraan ng listahan ng naka-link.

Ang pamamaraan ng Tanggalin ang isang Node ay naghahanap ng isang naibigay na node, tatanggalin ang node na iyon, at maiugnay ang nakaraang node sa sumusunod sa node na tinanggal.

Tanggalin ang isang Halimbawa ng Pamamaraan ng Node

Nasa ibaba ang isang halimbawa ng tanggalin ang isang paraan ng 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();
}
}

Gamit ang Halimbawa ng Tanggalin ang isang Paraan ng Node

Nasa ibaba ang isang halimbawa ng paggamit ng tanggalin ang isang node na pamamaraan sa pagsasanay.

kung paano makita ang aktibidad sa pagitan ng dalawang kaibigan sa facebook
//delete the node that holds the data 4
List.findAndDelete(4);
//print all nodes in the linked list
List.displayAllNodes();

Ang paggamit ng dalawang linya ng code sa itaas sa paunang mayroon na klase ng Driver ay makakapagdulot ng sumusunod na output sa console:

The List:
2 6 8 10

Ngayon Maaari kang Lumikha ng Mga Naka-link na Listahan sa Java

Kung nakarating ka sa pagtatapos ng artikulong ito sa tutorial, malalaman mo:

  • Paano lumikha ng isang klase ng node.
  • Paano lumikha ng isang naka-link na klase ng listahan.
  • Paano mapuno ang isang naka-link na klase ng listahan sa mga paunang natukoy na pamamaraan.
  • Paano lumikha ng isang klase ng driver at gamitin ang iba't ibang mga paraan ng listahan ng naka-link upang makamit ang nais na resulta.

Ang isang naka-link na listahan ay isa lamang sa maraming mga istruktura ng data na maaari mong gamitin upang mag-imbak, makuha at matanggal ang data. Dahil nakuha mo na ang lahat ng kailangan mo upang makapagsimula, bakit hindi subukan ang mga halimbawang ito para sa iyong sarili sa Java?

Magbahagi Magbahagi Mag-tweet Email Paano Lumikha at Magsagawa ng Mga Operasyon sa Mga Array sa Java

Pag-aaral ng Java? Hayaan ang mga arrays na hawakan ang iyong data nang madali.

Basahin Susunod Mga Kaugnay na Paksa
  • Programming
  • Java
  • Programming
  • Mga Tip sa Coding
Tungkol sa May-akda Kadeisha Kean(21 Artikulo Nai-publish)

Si Kadeisha Kean ay isang Full-Stack Software Developer at Teknikal / Teknikal na Manunulat. Siya ay may natatanging kakayahan na gawing simple ang ilan sa mga pinaka kumplikadong teknolohikal na konsepto; paggawa ng materyal na maaaring madaling maunawaan ng anumang baguhan sa teknolohiya. Siya ay madamdamin tungkol sa pagsusulat, pagbuo ng mga kagiliw-giliw na software, at paglalakbay sa buong mundo (sa pamamagitan ng mga dokumentaryo).

Higit pa Mula kay Kadeisha Kean

Mag-subscribe sa aming newsletter

Sumali sa aming newsletter para sa mga tip sa tech, pagsusuri, libreng ebook, at eksklusibong deal!

Mag-click dito upang mag-subscribe