पहला लास्ट जावा लिंक्ड सूची/नोड्स

Question

मैं उलझन में हूं कि प्रत्येक नोड दूसरे से कैसे जुड़ता है और यह सुनिश्चित करने के लिए कि अगर मैं अंत में एक के बाद पहले नोड को जोड़ना चाहता हूं, तो मैं नहीं चला रहा अनंत लूप। उदाहरण के लिए, इस समस्या में ..

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

[18, 4, 27, 9, 54, 5, 63] यदि आपने सूची का कॉल किया है। सबसे पहले() ;, सूची इस क्रम में तत्वों को संग्रहीत करेगी:

[4, 27, 9, 54, 5, 63, 18] यदि सूची खाली है या केवल एक तत्व है, तो इसकी सामग्री नहीं होनी चाहिए संशोधित किया जाना चाहिए।

मेरा पहला प्रयास कोई लाभ नहीं हुआ this..but करना है:

`public void firstLast(){ 
    ListNode temp = front;//stores/references the first node 
    temp.next = null;//ensures that first node isn't referring to any other 
//node 
    ListNode current = front;//reaches end node/first one with a null 
//reference 
    while(current.next != null){ 
     current = current.next; 
    } 
    front.next = temp;//links end node to first node 
    front = current.next;////now that skips the first element` 

लेकिन उत्पादन [18] -> [18] (cycles!) है। कृपया सलाह दें

Answer 1

मैं कैसे प्रत्येक नोड एक और

से लिंक होता है एक भी लिंक्ड सूची में पर उलझन में हूँ, प्रत्येक नोड केवल अगले एक को जानता है। तो आपको पहले, को ट्रैक करने की आवश्यकता है जिसे आमतौर पर head कहा जाता है (आपके कार्यान्वयन में यह "सामने"), है क्योंकि सभी तत्वों तक पहुंचना आवश्यक है।

... और यह सुनिश्चित करने के लिए कि अगर मैं अंत में एक के बाद पहले नोड को लिंक करना चाहता हूं, तो मैं अनंत लूप नहीं चला रहा हूं।

पिछले नोड यह बाद कोई अगले नोड है, इसलिए यह next सूचक null है। आप अनंत लूप से बचने के लिए इस स्थिति का उपयोग कर सकते हैं। (बस सुनिश्चित करें कि पिछले नोड next सही ढंग से है null के रूप में करते हैं।)

आपका कार्यान्वयन के रूप में तय किया जा सकता है:

public void firstLast() { 
    // list is empty or has single element -> nothing to do 
    if (front == null || front.next == null) { 
     return; 
    } 

    // save the first 
    ListNode first = front; 

    // move the head 
    front = front.next; 

    // find the end 
    ListNode current = front; 
    while (current.next != null) { 
     current = current.next; 
    } 

    // append the node 
    current.next = first; 

    // reset the next pointer of the new last node 
    first.next = null; 
} 

Answer 2

समारोह firstLast() के रूप में कोडित किया जा सकता है:

public void firstLast() 
{ 
    ListNode temp = removeFirst(); 
    appendLast(temp); 
} 

तो, अब आप इस समस्या को दो छोटे समस्याओं में टूट गए हैं। यह किसी भी तरह की समस्या को हल करने के लिए एक बहुत अच्छी रणनीति है।

आपके removeFirst() को लागू करने के लिए आपको जिस बिंदु को याद रखना है, वह है कि आपको front को दूसरे नोड को इंगित करने के लिए संशोधित करना है, जो front.next है।

Answer 3

को देखते हुए आप कार्यान्वित:

void push(ListItem item) { 
    end.next = item; 
    item.next = null; 
} 

और

ListItem pop() { 
    ListItem first = front; 
    front = front.next; 
    return first; 
} 

अपने विधि हो जाता है:

void firstLast() { 
    push(pop()); 
} 

नोट: कोई भी चेक के साथ अपरीक्षित कोड के लिए अशक्त रों या सूची आकार।