జావాలో లింక్డ్ లిస్ట్‌లను ఉపయోగించడం గురించి ఒక పరిచయం

సమర్థవంతమైన ప్రోగ్రామ్‌ల సృష్టిలో ముగిసిన డేటాను నిల్వ చేయడానికి, తిరిగి పొందడానికి మరియు తొలగించడానికి డేటా స్ట్రక్చర్ విభిన్న ముందే నిర్వచించిన పద్ధతులను ఉపయోగిస్తుంది. లింక్ చేయబడిన జాబితా అనేది ఒక ప్రముఖ డేటా స్ట్రక్చర్, ఇందులో కనెక్ట్ చేయబడిన (లేదా లింక్ చేయబడిన) నోడ్‌ల జాబితా ఉంటుంది.

కానీ మీరు జావాలో లింక్ చేయబడిన జాబితాను ఎలా సృష్టించాలి? ఒకసారి చూద్దాము.

---

---

లింక్ చేయబడిన జాబితా ఎలా పని చేస్తుంది?

లింక్ చేయబడిన ప్రతి జాబితా ప్రత్యేక నోడ్‌తో ప్రారంభమవుతుంది, దీనిని తరచుగా 'హెడ్' అని సూచిస్తారు, ఇది జాబితా ప్రారంభాన్ని ఎప్పుడైనా సూచించే బాధ్యతను కలిగి ఉంటుంది. తల ముఖ్యమైనది ఎందుకంటే లింక్ చేయబడిన లిస్ట్‌లోని ప్రతి నోడ్ దాని వారసుడిని భౌతికంగా అనుసరించాల్సిన అవసరం లేదు (అంటే పూర్వీకుడు మరియు వారసుడు భౌతికంగా ప్రక్కనే ఉండాల్సిన అవసరం లేదు).

ప్రతి డేటా నిర్మాణం వలె, లింక్ చేయబడిన జాబితా ఏదైనా డెవలపర్ ఉపయోగించగల ముందే నిర్వచించిన ఫంక్షన్ల ద్వారా సృష్టించడం, తిరిగి పొందడం, చొప్పించడం మరియు నాశనం చేయడాన్ని సులభతరం చేస్తుంది.

జావాలో లింక్డ్ లిస్ట్ సృష్టిస్తోంది

లింక్ చేయబడిన జాబితాలను రూపొందించడానికి మరియు తారుమారు చేయడానికి రూపొందించబడిన జావా ప్రోగ్రామ్ మూడు విలక్షణమైన విభాగాలను కలిగి ఉంటుంది; నోడ్ క్లాస్, లింక్డ్ లిస్ట్ క్లాస్ మరియు డ్రైవర్. ఈ మూడు విభాగాలు ఒక ఫైల్‌లో కలపగలిగినప్పటికీ, కంప్యూటర్ డెవలపర్‌లో ప్రతి ఒక్క డెవలపర్ తెలుసుకోవలసిన 'ఆందోళనల విభజన' అని పిలువబడే డిజైన్ సూత్రం ఉంది.

ఆందోళనల విభజన సూత్రం ఒక నిర్దిష్ట ఆందోళనను పరిష్కరించే కోడ్‌లోని ప్రతి విభాగాన్ని వేరు చేయాలని నిర్దేశిస్తుంది. ఈ సూత్రం మీకు క్లీనర్ (మరింత చదవగలిగే) కోడ్‌ని సృష్టించడానికి సహాయపడుతుంది మరియు డేటా స్ట్రక్చర్‌లను రూపొందించడానికి అనువైనది.

జావాలో లింక్ చేయబడిన జాబితాను రూపొందించడంలో మొదటి దశ నోడ్ క్లాస్‌ని సృష్టించడం. ఒక నోడ్ క్లాస్ రెండు లక్షణాలను కలిగి ఉండాలి; లక్షణాలలో ఒకటి నోడ్ యొక్క డేటా భాగాన్ని సూచిస్తుంది, మరొక లక్షణం లింక్ చేయబడిన భాగాన్ని సూచిస్తుంది. నోడ్ క్లాస్‌లో కన్స్ట్రక్టర్, గెట్టర్స్ మరియు సెట్టర్‌లు కూడా ఉండాలి.

---

---

సంబంధిత: జావాలో తరగతులను ఎలా సృష్టించాలో తెలుసుకోండి

గెట్టర్లు మరియు సెట్టర్‌లు ఇతర తరగతులను (లింక్డ్ లిస్ట్ క్లాస్ వంటివి) లింక్డ్ లిస్ట్‌లోని వివిధ నోడ్‌లను యాక్సెస్ చేయడానికి అనుమతిస్తుంది.

---

---

నోడ్ క్లాస్ ఉదాహరణ

మేము అర్థం ఏమిటో తెలుసుకోవడానికి దిగువన ఒక నోడ్ క్లాస్ ఉదాహరణ ఉంది:


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

ఈ ఉదాహరణలో, డేటా లక్షణం పూర్ణాంక విలువలను నిల్వ చేస్తుంది. ఇప్పుడు మీకు నోడ్ క్లాస్ ఉంది, లింక్ చేసిన లిస్ట్‌కి వెళ్లడానికి సమయం ఆసన్నమైంది.

లింక్ చేసిన జాబితా ఉదాహరణ

జావాలో లింక్ చేయబడిన జాబితా యొక్క ఉదాహరణ క్రింద ఉంది.

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


పై కోడ్ లింక్ చేయబడిన లిస్ట్ క్లాస్‌ని సృష్టిస్తుంది, అయితే, దాని వివిధ కార్యకలాపాలు లేకుండా, క్లాస్‌ను ఖాళీ షెల్‌తో సమానంగా చూడవచ్చు. లింక్ చేయబడిన డేటా డేటా స్ట్రక్చర్‌లో అనేక ఆపరేషన్‌లు ఉన్నాయి, వీటిని జనసాంద్రత కోసం ఉపయోగించవచ్చు:

• ముందు భాగంలో చొప్పించండి.
• మధ్యలో చొప్పించండి.
• వెనుక భాగంలో చొప్పించండి.

సంబంధిత: జావాస్క్రిప్ట్ ES6 క్లాస్‌లతో డేటా స్ట్రక్చర్‌లను ఎలా నిర్మించాలి

చొప్పించే పద్ధతుల లింక్ జాబితా సేకరణ ఒక డెవలపర్ ఈ డేటా నిర్మాణాన్ని స్టాక్స్ వంటి మరొక డేటా నిర్మాణంపై ఉపయోగించడానికి ఎంచుకోవడానికి ఒక కారణం (ఇది ఎగువ నుండి చొప్పించడం మరియు తొలగింపును మాత్రమే అనుమతిస్తుంది).

ఫ్రంట్ మెథడ్‌లో ఇన్సర్ట్ ఉపయోగించడం

ఫ్రంట్ మెథడ్‌లోని ఇన్సర్ట్, పేరు సూచించినట్లుగా, లింక్ చేయబడిన లిస్ట్ ముందు భాగంలో కొత్త డేటాను (లేదా కొత్త నోడ్స్) ఇన్సర్ట్ చేస్తుంది.

ఫ్రంట్ మెథడ్ ఉదాహరణలో చొప్పించండి

మీ జాబితా ముందు భాగంలో మీరు కొత్త డేటాను ఎలా ఇన్సర్ట్ చేస్తారనే దానికి ఉదాహరణ క్రింద ఉంది.

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


ది insertAtFront పై ఉదాహరణలోని పద్ధతి వినియోగదారుని ఇచ్చిన లింక్ జాబితాకు కొత్త నోడ్‌లను జోడించడానికి అనుమతిస్తుంది.

ముందు ఉదాహరణలో చొప్పించును వర్తింపజేయడం

మీరు ముందు భాగంలో ఇన్సర్ట్‌ను ఎలా వర్తింపజేస్తారనేదానికి ఉదాహరణ క్రింద ఉంది.

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


ది డ్రైవర్ తరగతి (ఇది జావాలోని ఎగ్జిక్యూటబుల్ క్లాస్‌కు తరచుగా కేటాయించబడే పేరు), ఐదు సరి సంఖ్యల లింక్ జాబితాను రూపొందించడానికి లింక్డ్‌లిస్ట్ క్లాస్‌ని ఉపయోగిస్తుంది. పైన ఉన్న కోడ్‌ని చూడటం వలన లింక్ చేయబడిన లిస్ట్‌లో '2' నంబర్ హెడ్ పొజిషన్‌లో ఉన్నట్లు సులభంగా తెలుస్తుంది. కానీ మీరు దీన్ని ఎలా నిర్ధారించవచ్చు?

యూట్యూబ్ హైలైట్ చేసిన వ్యాఖ్య ఏమిటి

డిస్‌ప్లే అన్ని నోడ్స్ పద్ధతిని ఉపయోగించడం

డిస్‌ప్లే అన్ని నోడ్స్ పద్ధతి అనేది తప్పనిసరిగా లింక్ చేయబడిన జాబితా పద్ధతి. ఇది లేకుండా, డెవలపర్ లింక్ చేయబడిన జాబితాలో నోడ్‌లను చూడలేరు. ఇది లింక్ చేయబడిన లిస్ట్ (హెడ్ నుండి మొదలుకొని) ద్వారా ప్రయాణిస్తుంది, జాబితాను రూపొందించే ప్రతి నోడ్‌లో స్టోర్ చేయబడిన డేటాను ప్రింట్ చేస్తుంది.

అన్ని నోడ్స్ పద్ధతి ఉదాహరణను ప్రదర్శించండి

జావాలో డిస్‌ప్లే అన్ని నోట్స్ పద్ధతిని ఉపయోగించే ఉదాహరణ క్రింద ఉంది.

//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 పద్ధతి దీనికి జోడించబడింది లింక్డ్లిస్ట్ క్లాస్ మీరు డ్రైవర్ క్లాస్‌కు ఒకే లైన్ కోడ్‌ను జోడించడం ద్వారా లింక్ చేసిన జాబితాను చూడవచ్చు.

డిస్‌ప్లే అన్ని నోడ్స్ మెథడ్ ఉదాహరణను ఉపయోగించడం

దిగువ, మీరు డిస్‌ప్లే అన్ని నోడ్స్ పద్ధతిని ఎలా ఉపయోగించాలో మీరు చూస్తారు.

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

పైన కోడ్ లైన్ అమలు చేయడం వలన కన్సోల్‌లో కింది అవుట్‌పుట్ ఉత్పత్తి అవుతుంది:

జాబితా:

2 4 6 8 10

ఫైండ్ నోడ్ పద్ధతిని ఉపయోగించడం

లింక్ చేయబడిన జాబితాలో వినియోగదారు నిర్దిష్ట నోడ్‌ను కనుగొనాలనుకున్న సందర్భాలు ఉంటాయి.

ఉదాహరణకు, లక్షలాది మంది కస్టమర్‌లు ఉన్న బ్యాంక్ నిర్దిష్ట ఖాతాదారుడి వివరాలను మాత్రమే చూడాల్సిన అవసరం వచ్చినప్పుడు వినియోగదారులందరినీ వారి డేటాబేస్‌లో ముద్రించడం ప్రాక్టికల్ కాదు.

అందువల్ల, ఉపయోగించడానికి బదులుగా displayAllNodes పద్ధతి, అవసరమైన డేటాను కలిగి ఉన్న సింగిల్ నోడ్‌ను కనుగొనడం మరింత సమర్థవంతమైన పద్ధతి. అందుకే లింక్డ్ డేటా స్ట్రక్చర్‌లో సింగిల్ నోడ్ పద్ధతి కోసం సెర్చ్ ముఖ్యమైనది.

నోడ్ పద్ధతి ఉదాహరణను కనుగొనండి

ఫైండ్ నోడ్ పద్ధతిని ఉపయోగించడానికి ఒక ఉదాహరణ క్రింద ఉంది.

//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 పద్ధతి, మీరు దీనిని ధృవీకరించారు లింక్డ్లిస్ట్ 2 నుండి 10 వరకు 5 సరి సంఖ్యలను కలిగి ఉంటుంది findNode పైన ఉన్న ఉదాహరణ కేవలం డ్రైవర్ క్లాస్‌లోని పద్ధతిని కాల్ చేయడం ద్వారా మరియు సంఖ్యను పారామీటర్‌గా అందించడం ద్వారా ఆ సరి సంఖ్యలలో ఒకటి సంఖ్యా 4 అని నిర్ధారించగలదు.

ఫైండ్ నోడ్ మెథడ్ ఉదాహరణను ఉపయోగించడం

మీరు ఆచరణలో ఫైండ్ నోడ్ పద్ధతిని ఎలా ఉపయోగించాలో క్రింద ఒక ఉదాహరణ.

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


పై కోడ్ కన్సోల్‌లో కింది అవుట్‌పుట్‌ను ఉత్పత్తి చేస్తుంది:

The node is in the list

ఒక నోడ్ పద్ధతిని తొలగించండి

పై నుండి అదే బ్యాంక్ ఉదాహరణను ఉపయోగించి, బ్యాంక్ డేటాబేస్‌లోని కస్టమర్ తమ ఖాతాను మూసివేయాలనుకోవచ్చు. ఇక్కడే డిలీట్ నోడ్ పద్ధతి ఉపయోగపడుతుంది. ఇది అత్యంత క్లిష్టమైన లింక్ జాబితా పద్ధతి.

తొలగించిన నోడ్ పద్ధతి ఇచ్చిన నోడ్ కోసం శోధిస్తుంది, ఆ నోడ్‌ను తొలగిస్తుంది మరియు మునుపటి నోడ్‌ను తొలగించిన నోడ్‌ని అనుసరించే దానికి లింక్ చేస్తుంది.

నోడ్ మెథడ్ ఉదాహరణను తొలగించండి

దిగువ నోడ్ పద్ధతిని తొలగించడానికి ఒక ఉదాహరణ.

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 the node that holds the data 4
List.findAndDelete(4);
//print all nodes in the linked list
List.displayAllNodes();

ముందుగా ఉన్న డ్రైవర్ క్లాస్‌లో పైన ఉన్న రెండు లైన్‌ల కోడ్‌ని ఉపయోగించడం వలన కన్సోల్‌లో కింది అవుట్‌పుట్ ఉత్పత్తి అవుతుంది:

The List:
2 6 8 10

ఇప్పుడు మీరు జావాలో లింక్డ్ లిస్ట్‌లను సృష్టించవచ్చు

మీరు ఈ ట్యుటోరియల్ ఆర్టికల్ చివరికి చేరుకున్నట్లయితే, మీరు నేర్చుకుంటారు:

• నోడ్ క్లాస్‌ని ఎలా సృష్టించాలి.
• లింక్ చేయబడిన లిస్ట్ క్లాస్‌ని ఎలా సృష్టించాలి.
• దాని ముందే నిర్వచించిన పద్ధతులతో లింక్ చేయబడిన జాబితా తరగతిని ఎలా జనసాంద్రత చేయాలి.
• కావలసిన ఫలితాన్ని సాధించడానికి డ్రైవర్ తరగతిని ఎలా సృష్టించాలి మరియు విభిన్న లింక్ జాబితా పద్ధతులను ఎలా ఉపయోగించాలి.

డేటాను నిల్వ చేయడానికి, తిరిగి పొందడానికి మరియు తొలగించడానికి మీరు ఉపయోగించే అనేక డేటా నిర్మాణాలలో లింక్ చేయబడిన జాబితా ఒకటి. మీరు ప్రారంభించడానికి కావలసినవన్నీ మీకు లభించాయి కాబట్టి, జావాలో మీ కోసం ఈ ఉదాహరణలను ఎందుకు ప్రయత్నించకూడదు?

షేర్ చేయండి షేర్ చేయండి ట్వీట్ ఇమెయిల్ జావాలో శ్రేణులపై ఆపరేషన్‌లను ఎలా సృష్టించాలి మరియు నిర్వహించాలి

జావా నేర్చుకుంటున్నారా? శ్రేణులు మీ డేటాను సులభంగా నిర్వహించడానికి అనుమతించండి.

తదుపరి చదవండి సంబంధిత అంశాలు

• ప్రోగ్రామింగ్
• జావా
• ప్రోగ్రామింగ్
• కోడింగ్ చిట్కాలు

రచయిత గురుంచి కదీషా కీన్(21 కథనాలు ప్రచురించబడ్డాయి)

కదీషా కీన్ పూర్తి-స్టాక్ సాఫ్ట్‌వేర్ డెవలపర్ మరియు టెక్నికల్/టెక్నాలజీ రైటర్. ఆమె చాలా క్లిష్టమైన సాంకేతిక భావనలను సరళీకృతం చేసే ప్రత్యేక సామర్థ్యాన్ని కలిగి ఉంది; ఏదైనా టెక్నాలజీ అనుభవం లేని వ్యక్తి సులభంగా అర్థం చేసుకోగల పదార్థాన్ని ఉత్పత్తి చేయడం. ఆమె రాయడం, ఆసక్తికరమైన సాఫ్ట్‌వేర్‌ను అభివృద్ధి చేయడం మరియు ప్రపంచాన్ని పర్యటించడం (డాక్యుమెంటరీల ద్వారా) పట్ల మక్కువ చూపుతుంది.

కదీషా కీన్ నుండి మరిన్ని

మా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి

టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్‌లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!

సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి