लिंक्ड सूची समारोह

Question

हटाएँ यहाँ एक लिंक्ड सूची से हटाने के लिए मेरी समारोह है:

void deleteList(NODE* head) 
{ 
    NODE* temp1; 
    NODE* tempNext; 
    temp1 = head; 
    tempNext = NULL; 

    while(temp1 != NULL) 
    { 
     tempNext = temp1->next; 
     free(temp1); 
     temp1 = tempNext; 
    } 
} 

तो temp1 पहले अंक जहां सिर सूचक इशारा कर रही है। यदि यह NULL नहीं है, tempNext सूची के अगले तत्व को इंगित करने के लिए सेट किया जाएगा। फिर पहला तत्व (temp1) मुक्त है, और temp1 को यह इंगित करने के लिए पुन: असाइन किया गया है कि tempNext इंगित करता है और दोहराने की प्रक्रिया करता है।

क्या यह पूरी सूची हटाने का सही दृष्टिकोण है?

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

Answer 1

आपका कोड सही दिखता है।

आप यह भी सही हैं कि एक सूची के तत्वों को मुक्त करने से वे तुरंत स्मृति को बदल नहीं पाते हैं। यह सिर्फ ढेर मैनेजर को स्मृति देता है जो इसे भविष्य में पुन: आवंटित कर सकता है।

आप यह सुनिश्चित करें कि ग्राहक कोड एक मुक्त कर दिया सूची का उपयोग करने के लिए जारी नहीं करता है बनाना चाहते हैं, तो आप को बदल सकता है deleteList भी अपने NODE सूचक शून्य पर:

void deleteList(NODE** head) 
{ 
    NODE* temp1 = *head; 
    /* your code as before */ 
    *head = NULL; 
} 

Answer 2

यह अभी भी सूची प्रिंट, क्योंकि आप शायद इस फ़ंक्शन को कॉल करने के बाद head पॉइंटर NULL पर सेट न करें।

Answer 3

I ask this because when I print the list after using this function, it still prints the list.

वहाँ free के बीच एक अंतर एक सूचक ing और एक सूचक अमान्य है। यदि आप free अपनी पूरी लिंक्ड सूची और सिर का मतलब है, तो इसका मतलब है कि अब head और next पॉइंटर्स पर उन स्थानों पर स्मृति "स्मृति" नहीं है। इस प्रकार आप garintee नहीं कर सकते हैं कि मूल्य क्या होगा, या स्मृति मान्य है।

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

struct node{ 
    int i; 
    struct node * next; 
}; 

... 
struct node * head = NULL; 
head = malloc(sizeof(struct node)); 
head->i = 5; 
head->next = NULL; 
free(head); 
printf("%d\n", head->i); // The odds are pretty good you'll see "5" here 

आप हमेशा अपने सूचक मुक्त कर देना चाहिए, तो सीधे क्योंकि उपरोक्त कोड में शून्य पर सेट है, जबकि टिप्पणी सच है। किसी भी को free() कहने के बाद प्रतिक्रिया/शामिल करने के बारे में धारणाएं भी खतरनाक हैं।

Answer 4

यह एक बहुत पुराना सवाल है, लेकिन शायद यह किसी विषय पर खोज करने में मदद करेगा।

यही वह है जिसे मैंने हाल ही में एकल-लिंक्ड सूची को पूरी तरह से हटाने के लिए लिखा है। मैं बहुत सारे लोगों को देखता हूं जो स्टैक स्पेस से बाहर निकलने के डर के लिए बड़ी सूचियों वाले रिकर्सिव एल्गोरिदम पर दिल की धड़कन रखते हैं। तो यहां एक पुनरावृत्ति संस्करण है।

बस "हेड" पॉइंटर में पास करें और फ़ंक्शन बाकी का ख्याल रखता है ...

struct Node { 
    int i; 
    struct Node *next; 

};

void DeleteList(struct Node *Head) { 

    struct Node *p_ptr; 

    p_ptr = Head; 

    while (p_ptr->next != NULL) { 
      p_ptr = p_ptr->next; 
      Head->next = p_ptr->next; 
      free(p_ptr); 
      p_ptr = Head; 
    } 

    free(p_ptr); 

}