जावा लिंक्ड लिस्ट - विधि

Question

डेटा स्ट्रक्चर क्लास, सिर, पूंछ और वर्तमान नोड्स के साथ एक सिंगल लिंक्ड-लिस्ट को लागू करना। एक विधि के साथ परेशानी होने के कारण, सही दिशा में एक झुकाव का उपयोग कर सकते हैं।

काम से, विधि लिखें:

(आइटम) जोड़ें: मद (स्ट्रिंग) सूची में वर्तमान नोड के बाद कहते हैं और वर्तमान सूचक नए नोड का उल्लेख करने के निर्धारित करता है।

मेरे प्रयास:

मेरे ऐड विधि केवल काम करने के लिए जब मैं सूची के बीच में आइटम डाले रहा हूँ, पर नहीं दोनों छोर लगता है। यदि मैं इसे कुछ आइटम जोड़ने के लिए उपयोग करता हूं और फिर सूची मुद्रित करता हूं, तो केवल पहले जो मैंने जोड़ा है, वह सूची में होगा, जबकि मेरे प्रीपेन्ड और एपेंड विधियों ने अभी ठीक परीक्षण किया है।

क्या मेरे कोड के साथ कोई चमकदार समस्या है? मुझे लगता है कि मुझे कुछ याद आ रही है।

सभी:

public class LinkedList { 
    Node head = null; /* Head of the list */ 
    Node tail = null; /* Tail of the list */ 
    Node curr = null; /* Current node in the list */ 

    public void prepend(String item) { 
     if (head == null) { 
      head = tail = new Node(item, null); 
      curr = head; 
     } else { 
      head = new Node(item, head); 
      curr = head; 
     } 
    } 

    public void append(String item) { 
     if (head == null) { 
      head = tail = new Node(item, null); 
      curr = tail; 
     } else { 
      tail.next = new Node(item, null); 
      tail = tail.next; 
      curr = tail; 
     } 
    } 

    public void add(String item) { 
     if (curr != null) { 
      Node newNode = new Node(item, curr.next); 
      curr.next = newNode; 
      curr = newNode; 
     } else { 
      head = tail = new Node(item, null); 
      curr = head; 
     } 
    } 

    public void delete() { 
     if (curr.next == null) { 
      Node temp = head; 
      while (temp.next != curr) { 
       System.out.println(temp.item); 
       temp = temp.next; 
      } 
      temp.next = null; 
      curr = head; 
     } 
    } 

    public void find(String item) { 
     Node temp = new Node(curr.item, curr.next); 
     if (item.equals(temp.item)) 
      curr = temp; 
     else { 
      temp = temp.next; 
      while (temp.next != null && temp != curr) { 
       if (item.equals(temp.item)) 
        curr = temp; 
      } 
     } 
    } 

    public String get() { 
     if (curr != null) 
      return curr.item; 
     else 
      return ""; 
    } 

    public boolean next() { 
     if (curr != tail) { 
      curr = curr.next; 
      return true; 
     } else 
      return false; 
    } 

    public void start() { 
     curr = head; 
    } 

    public void end() { 
     curr = tail; 
    } 

    public boolean empty() { 
     if (head == null) 
      return true; 
     else 
      return false; 
    } 
} 

Node वर्ग:

class Node { 
    Node next; 
    String item; 

    Node(String item, Node next) { 
     this.next = next; 
     this.item = item; 
    } 
} 

Answer 1

मुझे लगता है कि समस्या यह है

if (curr != null) { 
    Node newNode = new Node(item, curr.next); //<-- here (curr.next) 

//and 

Node(String item, Node next) { 
    this.next = next; //<-- here 

कोशिश (संपादित):

Node newNode = new Node(item, curr); // pass curr to the constructor of Node 
curr = newNode; 

Answer 2

मुझे यहां कोई समस्या नहीं दिख रही है, इसलिए मुझे लगता है कि यह मुद्दा कहीं और है।

ठीक है, केवल मुद्दा मैं वहाँ देखने हटाने में है:

public void delete() 
{ 
    Node temp = head; 

    while(temp != null && temp.next != curr) { 
     System.out.println(temp.item); 
     temp=temp.next; 

    } 

    if (temp != null && temp.next != null) { 
     temp.next = temp.next.next; 
    } 
    curr = head; 

} 

Answer 3

मुझे लगता है कि मैं आपकी समस्या को मिल गया है। यदि आप परिशिष्ट() का उपयोग करते हैं तो आप इसे सीधे पूंछ के बाद जोड़ते हैं। लेकिन जब आपने पूंछ के बाद पिछले नोड्स जोड़े हैं तो आप अपनी पूंछ को नए नोड पर सेट नहीं करते हैं। इसका अर्थ यह है कि एक बार जब आप दोबारा जोड़ते हैं() दो बार आप उन सभी नोड्स को खो देते हैं जिन्हें आपने पहले एपेंड() के बाद जोड़ा है।

संक्षिप्त उदाहरण:

public static void main(String[] args) { 
    LinkedList list = new LinkedList(); 
    list.add("First add"); 
    list.append("First Append"); 
    list.add("Second add"); 
    list.prepend("First prepend"); 
    list.add("Third add"); 
    list.prepend("Second prepend"); 
    list.add("fourth add"); 
    list.append("Second Append"); 
    list.add("Fifth add"); 
    list.add("Sixth add"); 

    list.start(); 
    do { 
     System.out.println(list.get().toString()); 

    } while (list.next()); 
} 

आउटपुट:

Second prepend 
fourth add 
First prepend 
Third add 
First add 
First Append 
Second Append 

निष्कर्ष: "दूसरा जोड़ें" खो दिया है, साथ ही क्योंकि अपने अगले() विधि "पांचवें जोड़ने" और "छठी जोड़ें" जैसे ही यह पूंछ तक पहुंचता है बंद हो जाता है। यदि आप अंत में एक नया नोड जोड़ते हैं तो आपको हमेशा पूंछ को अपडेट करने की आवश्यकता होती है।

उम्मीद है कि इससे मदद मिलती है। चीयर्स, च्नोच

Answer 4

add में वास्तव में एक समस्या है: यह tail अद्यतन नहीं करता है जब नोड्स पहले से मौजूद हैं।

public void print() { 
    Node curr = this.head; 
    while(curr != null) { 
     System.out.println(curr.item); 
     curr = curr.next; 
    } 
} 

इस तरह

:

LinkedList list = new LinkedList(); 
list.add("one"); 
list.add("two"); 
list.append("three"); 

यदि आप थे तो यह इस का उपयोग कर मुद्रित करने के लिए: कार्यों के इस क्रम पर विचार करें

list.print(); 

आप निम्न आउटपुट प्राप्त चाहते हैं:

one 
three 

ऐसा होता है औस tail - जो append पर निर्भर करता है - दूसरे add ऑपरेशन के बाद पहले Node पर इंगित करता है।