జావాలో లింక్డ్ లిస్ట్ డేటా స్ట్రక్చర్

విభిన్న ప్రయోజనాల కోసం వేర్వేరు డేటా నిర్మాణాలు సృష్టించబడతాయి. మీకు ArrayList గురించి తెలిసి ఉండవచ్చు (అప్పటికీ కాకపోతే, దాని గురించి ముందుగా చదవమని మేము మీకు సిఫార్సు చేస్తున్నాము). ఈ కథనంలో, మేము లింక్డ్‌లిస్ట్ గురించి నేర్చుకోబోతున్నాము మరియు ఈ సేకరణ దేనికి మంచిదో తెలుసుకోవడం. మీరు లింక్డ్‌లిస్ట్ జావా 8 (లేదా భాష యొక్క తదుపరి వెర్షన్) క్లాస్ కోడ్ మూలాన్ని (ఒరాకిల్ వెబ్‌సైట్‌లో లేదా మీ IDEలో, IDEA: క్లాస్ పేరుపై crtl+B) చూస్తే, మీకు తదుపరి డిక్లరేషన్ కనిపిస్తుంది:

public class LinkedList<E>
   extends AbstractSequentialList<E>
   implements List<E>, Deque<E>, Cloneable, java.io.Serializable

ప్రస్తుతానికి లింక్డ్‌లిస్ట్ జాబితా మరియు డీక్యూ ఇంటర్‌ఫేస్‌లను అమలుచేస్తుందనేది కోడ్ నుండి అత్యంత ముఖ్యమైన సమాచారం . జాబితా ఇంటర్‌ఫేస్ ఐటెమ్‌లను జోడించే క్రమాన్ని ఉంచుతుంది మరియు ఇండెక్స్ ద్వారా ఐటెమ్‌కు యాక్సెస్‌ను అనుమతిస్తుంది. "సాధారణ" క్యూ ముగింపుకు మూలకాలను జోడించడానికి మరియు మొదటి నుండి వాటిని సంగ్రహించడానికి మద్దతు ఇస్తుంది. Deque అనేది రెండు-మార్గం క్యూ, మరియు ఇది రెండు వైపుల నుండి ఎలిమెంట్‌లను జోడించడానికి మరియు తీసివేయడానికి మద్దతు ఇస్తుంది. మీరు దీన్ని స్టాక్ మరియు క్యూ కలయికగా భావించవచ్చు. కాబట్టి, లింక్డ్‌లిస్ట్ అనేది ఈ రెండింటి యొక్క అమలు, మరియు ఇది శూన్యంతో సహా ఏదైనా వస్తువులను కలిగి ఉన్న ద్వి దిశాత్మక క్యూను సృష్టించడానికి మాకు అనుమతిస్తుంది. లింక్డ్లిస్ట్అంశాల సమాహారం. మేము దానిని తరగతి కోడ్ సోర్స్‌లో చూడవచ్చు, ఈసారి ఫీల్డ్‌లకు శ్రద్ధ వహించండి:

transient int size = 0;
/**
* Pointer to first node.
*/
transient Node<E> first;
/**
* Pointer to last node.
*/
transient Node<E> last;

ప్రతి మూలకం, సాధారణంగా దీనిని నోడ్ అని పిలుస్తాము , ఒక వస్తువు మరియు రెండు పొరుగు వస్తువులకు సూచనలను కలిగి ఉంటుంది - మునుపటి మరియు తదుపరిది. అందువల్ల, మెమరీని ఉపయోగించడం పరంగా ఇది చాలా ప్రభావవంతంగా ఉండదు. లింక్డ్‌లిస్ట్ వాస్తవానికి ద్విదిశాత్మక నిర్మాణం కాబట్టి , మేము రెండు వైపుల నుండి అంశాలను సులభంగా జోడించవచ్చు లేదా తీసివేయవచ్చు.

లింక్డ్‌లిస్ట్ కన్‌స్ట్రక్టర్‌లు

తిరిగి కోడ్ మూలానికి, లింక్డ్‌లిస్ట్‌లో ఇద్దరు కన్‌స్ట్రక్టర్‌లు ఉన్నాయని మనం కనుగొనవచ్చు

• పారామితులు లేకుండా LinkedList() ఖాళీ జాబితాను నిర్మించడానికి ఉపయోగించబడుతుంది.
• >లింక్డ్‌లిస్ట్(కలెక్షన్<? విస్తరిస్తుంది E> c) అనేది పేర్కొన్న సేకరణ యొక్క మూలకాలను కలిగి ఉన్న జాబితాను సృష్టించడం కోసం, క్రమంలో, అవి సేకరణ యొక్క ఇటరేటర్ ద్వారా అందించబడతాయి.

లింక్డ్‌లిస్ట్ డిక్లరేషన్

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

LinkedList<Integer> myList = new LinkedList<>();

పూర్ణాంకాల క్రమాన్ని మరియు పొరుగువారికి లింక్‌లను ఉంచడానికి మాకు ఒక వస్తువు ఉంది. అయితే, ప్రస్తుతం ఖాళీగా ఉంది.

లింక్డ్‌లిస్ట్ ప్రధాన కార్యకలాపాలు

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

• add(E మూలకం) ఈ జాబితా చివర పేర్కొన్న మూలకాన్ని జోడిస్తుంది;
• add(int సూచిక, E మూలకం) పేర్కొన్న స్థాన సూచిక వద్ద మూలకాన్ని చొప్పిస్తుంది ;
• get(int ఇండెక్స్) ఈ జాబితాలో పేర్కొన్న స్థానం వద్ద మూలకాన్ని అందిస్తుంది;
• తొలగించు(int సూచిక) స్థానం సూచిక వద్ద ఉన్న మూలకాన్ని తొలగిస్తుంది;
• తొలగించు(ఆబ్జెక్ట్ o) యొక్క మొదటి సంఘటనను తొలగిస్తుంది? ఈ జాబితా నుండి o మూలకం ఉంటే.
• remove() జాబితా యొక్క మొదటి మూలకాన్ని తిరిగి పొందుతుంది మరియు తీసివేస్తుంది.

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

ఆచరణలో ఈ ఆపరేషన్లను ప్రయత్నిద్దాం. ముందుగా, జావా లింక్డ్‌లిస్ట్ అమలు: లింక్డ్ లిస్ట్ ఆఫ్ స్ట్రింగ్‌లను సృష్టించడం, అక్కడ 3 ఎలిమెంట్‌లను జోడించడం. ఆపై ఒకదాన్ని తీసివేసి, మధ్యలో ఒకదాన్ని జోడించండి.

public class MyLinkedTest {
   public static void main(String[] args) {
       String h1 = "my";
       String h2 = "favorite";
       String h3 = "book";
//  LinkedList implementation in Java
       LinkedList<String> linkedList = new LinkedList();
       linkedList.add(h1);
       linkedList.add(h2);
       linkedList.add(h3);
       System.out.println("my list after adding 3 elements:");
       System.out.println(linkedList);
       System.out.println("element #2 of my list:");
       System.out.println(linkedList.get(2));
       linkedList.remove(1);
       System.out.println("my list after removing #1:");
       System.out.println(linkedList);
       linkedList.add(1,"first");
       System.out.println("my list after adding an element in the middle");
       System.out.println(linkedList);
   }

ఈ ప్రోగ్రామ్ అమలు ఫలితంగా:

my list after adding 3 elements:
[my, favorite, book]
element #2 of my list:
book
my list after removing #1:
[my, book]
my list after adding an element in the middle
[my, first, book]

లింక్డ్‌లిస్ట్ అనేది కలెక్షన్ ఫ్రేమ్‌వర్క్‌లో ఒక భాగం , మీరు ఎలిమెంట్‌లను తీసివేయడానికి ఇటరేటర్‌ని ఉపయోగించవచ్చు, అలాగే జాబితాల కోసం ప్రత్యేక ఇటరేటర్‌ను ఉపయోగించవచ్చు — ListIterator . ఇంకా ఎక్కువగా, ఇటరేటర్‌తో కార్యకలాపాలు లింక్డ్‌లిస్ట్ క్లాస్ యొక్క ప్రధాన ప్రయోజనాలను అందిస్తాయి : ఇన్సర్ట్/డిలీట్ ఆపరేషన్‌ల యొక్క మంచి పనితీరు. ఇటరేటర్‌ని ఉపయోగించి మీరు వాటి కోసం స్థిరమైన సమయాన్ని పొందవచ్చు. ఈ కథనంలో తర్వాత, మేము అర్రేలిస్ట్ మరియు లింక్డ్‌లిస్ట్+ఇటరేటర్‌లను పోల్చడానికి కోడ్ ఉదాహరణను వ్రాస్తాము

• Iterator.remove() ఈ ఇటరేటర్ ద్వారా అందించబడిన చివరి మూలకాన్ని తొలగిస్తుంది.
• ListIterator.add(E మూలకం) జాబితాలోకి ఒక మూలకాన్ని చొప్పిస్తుంది

జావా లింక్డ్‌లిస్ట్ ఉదాహరణ: ఇటరేటర్ ఎలా పనిచేస్తుంది

ఇక్కడ మనకు చిన్న జావా లింక్డ్‌లిస్ట్ ఉదాహరణ కోడ్ ఉంది, ఇక్కడ మేము ఇటరేటర్ ద్వారా జోడించడానికి మరియు తొలగించడానికి ప్రయత్నిస్తాము.

public class MyLinkedTest {
   public static void main(String[] args) {
       String h1 = "my";
       String h2 = "favorite";
       String h3 = "book";
       LinkedList<String> linkedList = new LinkedList();
       linkedList.add(h1);
       linkedList.add(h2);
       linkedList.add(h3);
 
       Iterator i = linkedList.iterator();
       String str = "";
       while (i.hasNext()) {
           str = (String)i.next();
           if (str.equals("favorite")) {
               i.remove();
               break;
           }
       }

       System.out.println("linkedList after removing element via Iterator:");
       System.out.println(linkedList);
       ListIterator listIterator = linkedList.listIterator();
       listIterator.add("I've got");
       System.out.println("linkedList after adding the element via ListIterator");
       System.out.println(linkedList);
 
   }
}

ఈ ప్రోగ్రామ్ అమలు ఫలితంగా:

linkedList after removing element via Iterator:
[my, book]
linkedList after adding the element via ListIterator
[I've got, my, book]

మరిన్ని జావా లింక్డ్‌లిస్ట్ కార్యకలాపాలు:

• addFirst() , addLast() ఒక మూలకాన్ని జాబితా ప్రారంభం/ముగింపుకు జోడించండి
• clear() జాబితా నుండి అన్ని అంశాలను తొలగిస్తుంది
• జాబితాలో o మూలకం ఉంటే కలిగి(Object o) నిజాన్ని అందిస్తుంది.
• indexOf(Object o) అనేది o మూలకం యొక్క మొదటి సంభవం యొక్క సూచికను అందిస్తుంది, లేదా అది జాబితాలో లేకుంటే -1.
• సెట్ (int సూచిక, E మూలకం) మూలకంతో ఇండెక్స్ స్థానంలో ఉన్న మూలకాన్ని భర్తీ చేస్తుంది
• size() జాబితాలోని మూలకాల పరిమాణాన్ని అందిస్తుంది.
• toArray() మొదటి నుండి చివరి మూలకం వరకు అన్ని జాబితా మూలకాలను కలిగి ఉన్న శ్రేణిని అందిస్తుంది.

BTW రెండు-పరిమాణ క్యూ, జావాలోని లింక్డ్‌లిస్ట్ నిర్దిష్ట కార్యకలాపాలను కలిగి ఉంది:

• pop() స్టాక్ నుండి ఒక మూలకాన్ని పాప్ చేస్తుంది (జాబితా ద్వారా సూచించబడుతుంది)
• పుష్(E e) ఒక మూలకాన్ని స్టాక్‌పైకి నెట్టివేస్తుంది (ఈ జాబితా ద్వారా సూచించబడుతుంది)

లింక్డ్‌లిస్ట్‌ను ఎలా రివర్స్ చేయాలి: ఉదాహరణ

ఇక్కడ ఒక చిన్న ఉదాహరణ, జనాదరణ పొందినది, ఇంకా ప్రారంభకులకు సులభమైన పని. మాకు లింక్డ్‌లిస్ట్ ఉంది మరియు దానిని రివర్స్ చేయాలి. లింక్డ్‌లిస్ట్ ద్వారా రివర్స్ ఆర్డర్‌లో వెళ్లి ప్రతి మూలకాన్ని కొత్తదానిలో ఉంచడం సులభమయిన అల్గోరిథం . అయితే, బహుశా మీరు మంచి మార్గాన్ని కనుగొంటారా? రివర్స్ లింక్డ్ లిస్ట్ జావా ప్రోగ్రామ్ కోడ్ ఇక్కడ ఉంది:

public class MyLinkedTest {
   public static void main(String[] args) {
       String h1 = "my";
       String h2 = "favorite";
       String h3 = "book";
       LinkedList<String> linkedList = new LinkedList();
       linkedList.add(h1);
       linkedList.add(h2);
       linkedList.add(h3);
       System.out.println(linkedList);
       System.out.println("Reversed LinkedList:");
       System.out.println(reverseLinkedList(linkedList));
   }
   public static LinkedList<String> reverseLinkedList(LinkedList<String> list)
   {
       LinkedList<String> LinkedList = new LinkedList<String>();
       for (int i = list.size() - 1; i >= 0; i--) {
           LinkedList.add(list.get(i));
       }
       return LinkedList;
   }
}

ఫలితం:

[I've got, my, book]
Reversed LinkedList:
[book, my, I've got]

లింక్డ్‌లిస్ట్ vs అర్రేలిస్ట్: మొదటిదాన్ని ఎప్పుడు ఉపయోగించాలి

లింక్డ్‌లిస్ట్ మరియు అర్రేలిస్ట్ రెండూ జాబితా ఇంటర్‌ఫేస్ యొక్క అమలు . లింక్డ్‌లిస్ట్ దీన్ని డబుల్-లింక్డ్ లిస్ట్‌తో అమలు చేస్తుంది. ArrayList డైనమిక్ రీసైజింగ్ శ్రేణిని ఉపయోగించి దీన్ని అమలు చేస్తుంది. మీకు ఇప్పటికే తెలిసినట్లుగా, లింక్డ్‌లిస్ట్ యొక్క ప్రతి నోడ్‌లో వస్తువులు మరియు పొరుగువారికి రెండు సూచనలు ఉంటాయి. అంటే జావా లింక్డ్‌లిస్ట్ విషయంలో మూలకాల మధ్య సూచనలను నిల్వ చేయడానికి అదనపు మెమరీ ఖర్చులు . అర్రేలిస్ట్ దీన్ని డైనమిక్ రీసైజింగ్ శ్రేణితో అమలు చేస్తుంది. కొన్ని లింక్డ్‌లిస్ట్ మరియు అర్రేలిస్ట్ ఆపరేషన్‌లు ఒకేలా కనిపిస్తాయి, కానీ అవి వేరే విధంగా పని చేస్తాయి. అర్రేలిస్ట్‌లో _సందర్భంలో, మీరు అంతర్గత శ్రేణులతో, లింక్డ్‌లిస్ట్‌లో — సూచనలతో మానిప్యులేట్ చేస్తారు. ArrayList అత్యంత ప్రజాదరణ పొందిన జాబితా అమలు. ఈ కార్యకలాపాలు స్థిరమైన సమయంలో నిర్వహించబడుతున్నందున సూచిక యాక్సెస్ ప్రాధాన్యత అయినప్పుడు మీరు ఖచ్చితంగా ArrayListని ఉపయోగించాలి . సగటున జాబితా ముగింపుకు జోడించడం కూడా స్థిరమైన సమయంలో జరుగుతుంది. ఇంకా ఎక్కువ, ఎలిమెంట్‌ల సమూహాన్ని నిల్వ చేయడానికి అర్రేలిస్ట్‌కి అదనపు ఖర్చులు లేవు. జాబితా చివరలో లేనప్పుడు చొప్పించడం మరియు తీసివేయడం కార్యకలాపాల వేగాన్ని మీరు నష్టాలుగా పరిగణించవచ్చు. లింక్డ్లిస్ట్కొన్ని మార్గాల్లో ఇన్సర్ట్ మరియు డిలీట్ ఆపరేషన్ల పనితీరు విషయంలో మరింత ఉపయోగకరంగా ఉంటుంది: మీరు ఇటరేటర్లను ఉపయోగిస్తే అది స్థిరమైన సమయంలో జరుగుతుంది. ఇండెక్స్ ద్వారా యాక్సెస్ కార్యకలాపాలు ముగింపు ప్రారంభం నుండి (ఏదైతే దగ్గరగా ఉందో) కావలసిన మూలకం వరకు శోధించడం ద్వారా నిర్వహించబడతాయి. అయితే, మూలకాల మధ్య సూచనలను నిల్వ చేయడానికి అదనపు ఖర్చుల గురించి మర్చిపోవద్దు. కాబట్టి ఇక్కడ ప్రామాణిక లింక్డ్‌లిస్ట్ మరియు అర్రేలిస్ట్ కార్యకలాపాలు అల్గారిథమిక్ రన్‌టైమ్‌లతో ఉంటాయి. N అనేది ఇప్పటికే జాబితాలో ఉన్న అంశాల సంఖ్యను సూచిస్తుంది. O(N) అంటే చెత్త సందర్భంలో మనం అవసరమైన స్థానం కనుగొనబడే వరకు మొత్తం జాబితా ద్వారా “నడవాలి”, ఉదాహరణకు, జాబితాలో కొత్త మూలకాన్ని చొప్పించడం కోసం. O(1)ఆపరేషన్ స్థిరమైన సమయంలో, స్వతంత్రంగా వస్తువుల సంఖ్యపై జరుగుతుంది.

లింక్డ్‌లిస్ట్ సమయ సంక్లిష్టత

అర్రేలిస్ట్ సమయ సంక్లిష్టత

లింక్డ్‌లిస్ట్‌ను ఎప్పుడు ఉపయోగించాలి: ఉదాహరణ

ఖచ్చితంగా, ArrayList అత్యంత ప్రజాదరణ పొందిన జాబితా అమలు. అయినప్పటికీ, యాడ్/తొలగింపు కార్యకలాపాలు చాలా తరచుగా అవసరమైనప్పుడు మీరు పరిస్థితులను ఎదుర్కోవచ్చు. అలాంటప్పుడు, ఇటరేటర్‌తో కలిసి లింక్డ్‌లిస్ట్ ప్రయోజనకరంగా ఉంటుంది. ఇక్కడ ఒక ఉదాహరణ ఉంది. మేము సుదీర్ఘ జాబితాను కలిగి ఉన్నాము మరియు మేము ఈ జాబితా నుండి ప్రతి మూలకాన్ని తొలగించాలి. ArrayList మరియు LinkedList + Iterator తో ఈ పనిని చేద్దాం . మేము ప్రతి ఆపరేషన్ సమయాన్ని సరిపోల్చాము మరియు దానిని కన్సోల్‌లోకి ప్రింట్ చేస్తాము. ఇక్కడ కోడ్:

import java.util.*;
import java.util.function.BiPredicate;
 
public class ListTest2 {
 
   static void removeElements(List<Double> list, BiPredicate<Integer, Double> predicate) {
       // start navigation from end to preserve indexes of removed items
       ListIterator<Double> iterator = list.listIterator(list.size());
 
       while (iterator.hasPrevious()) {
           Double element = iterator.previous();
           if (predicate.test(iterator.previousIndex()+1, element)) {
               iterator.remove();
           }
       }
   }
 
   static class TestCase1 {
       public static void main(String[] args) {
           LinkedList<Double> testedList1 = new LinkedList<>(Arrays.asList(2.0,9.0,3.0,12.0,5.0));
           removeElements(testedList1, (index, value) -> (value % 3 == 0));
           // should print `[2.0, 5.0]`
           System.out.println("testedList1 after removeElements(..): " + testedList1);
 
           ArrayList<Double> testedList2 = new ArrayList<>(Arrays.asList(2.0,9.0,3.0,12.0,5.0));
           removeElements(testedList2, (index, value) -> (value % 3 == 0));
           // should print `[2.0, 5.0]`
           System.out.println("testedList2 after removeElements(..): " + testedList2);
       }
   }
 
   static class TestLinkedListPerformance {
       public static void main(String[] args) {
           LinkedList<Double> testedList = new LinkedList<>();
           System.out.println("start filling testedList");
           for (int i = 0; i < 2 * 1000 * 1000 ; ++i) {
               testedList.add((double)i);
           }
 
           System.out.println("start treating testedList");
           long startTime = System.nanoTime();
           removeElements(testedList, (index, value) -> (value % 3 == 0));
           long endTime = System.nanoTime();
           // should print `1333333`
           System.out.println("testedList.size after removeElements(..): " + testedList.size());
           // could print `0.1527659`
           System.out.println("removeElements(..) takes (seconds): " + ((double)(endTime - startTime)) / 1000000000);
       }
   }
 
   static class TestArrayListPerformance {
       public static void main(String[] args) {
           ArrayList<Double> testedList = new ArrayList<>();
           System.out.println("start filling testedList");
           for (int i = 0; i < 2 * 1000 * 1000 ; ++i) {
               testedList.add((double)i);
           }
 
           System.out.println("start treating testedList");
           long startTime = System.nanoTime();
           removeElements(testedList, (index, value) -> (value % 3 == 0));
           long endTime = System.nanoTime();
           // should print `1333333`
           System.out.println("testedList.size after removeElements(..): " + testedList.size());
           // could print `53.4952635`
           System.out.println("removeElements(..) takes (seconds): " + ((double)(endTime - startTime)) / 1000000000);
       }
   }
}

అర్రేలిస్ట్ కోసం ఫలితాలు:

start filling testedList
start treating testedList
testedList.size after removeElements(..): 1333333
removeElements(..) takes (seconds): 481.8824414

లింక్డ్‌లిస్ట్ కోసం ఫలితాలు:

start filling testedList
start treating testedList
testedList.size after removeElements(..): 1333333
removeElements(..) takes (seconds): 0.4586458

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

యాడ్ఆన్: సింగిల్ లింక్డ్ జాబితా జావా

జావాలోని క్లాసికల్ కలెక్షన్‌లో సింగిల్ లింక్డ్ లిస్ట్ ఏదీ లేదు , సింగిల్ లింక్డ్ లిస్ట్ అనేది ప్రతి నోడ్‌లో ఆబ్జెక్ట్ మరియు తదుపరి నోడ్‌కి సూచన ఉంటుంది, కానీ మునుపటిది కాదు. Java లింక్డ్‌లిస్ట్ రెండు-లింక్డ్, కానీ మీ స్వంత డేటా స్ట్రక్చర్‌ని సృష్టించడానికి ఎవరూ మీతో జోక్యం చేసుకోరు, ఉదాహరణకు Singly ,code>Linked List. ఈ పనులను పరిష్కరించడానికి ఇక్కడ కొన్ని దశలు ఉన్నాయి:

1. డేటా మరియు తదుపరి రెండు లక్షణాలతో నోడ్ తరగతిని సృష్టించండి . తదుపరిది తదుపరి నోడ్‌కు సూచన.
2. తల మరియు తోక అనే రెండు లక్షణాలతో ఫస్ట్‌లాస్ట్ క్లాస్‌ని సృష్టించండి .
3. జాబితాకు కొత్త నోడ్‌ను జోడించడానికి యాడ్() పద్ధతిని సృష్టించండి . జాబితా మొదట ఖాళీగా ఉందో లేదో తనిఖీ చేయండి ( తల == శూన్యం ). అలా అయితే, తల మరియు తోక కొత్త నోడ్‌ను సూచిస్తాయి. జాబితా ఖాళీగా లేకుంటే, కొత్త నోడ్ చివరకి జోడించబడుతుంది, కాబట్టి తోక యొక్క తదుపరి లక్షణం జోడించిన నోడ్‌ను సూచిస్తుంది మరియు కొత్త నోడ్ జాబితా యొక్క తోకగా మారుతుంది.

మార్గం ద్వారా మీరు మీ స్వంత లింక్డ్‌లిస్ట్‌ను వ్యాయామంగా కూడా సృష్టించడానికి ప్రయత్నించవచ్చు . మీ అభ్యాసంలో అదృష్టం.