wake-up-neo.com

C: Wie werden Knoten in der verknüpften Liste freigegeben?

Wie kann ich die in einer anderen Funktion zugewiesenen Knoten freigeben?

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

struct node* buildList()
{
    struct node* head = NULL;
    struct node* second = NULL;
    struct node* third = NULL;

    head = malloc(sizeof(struct node));
    second = malloc(sizeof(struct node));
    third = malloc(sizeof(struct node));

    head->data = 1;
    head->next = second;

    second->data = 2;
    second->next = third;

    third->data = 3;
    third->next = NULL;

    return head;
}

Ich rufe die buildList-Funktion in der main () auf 

int main()
{
    struct node* h = buildList();
    printf("The second element is %d\n", h->next->data);
    return 0;
}

Ich möchte Kopf, zweite und dritte Variablen befreien.
Vielen Dank.

Aktualisieren: 

int main()
{
    struct node* h = buildList();
    printf("The element is %d\n", h->next->data);  //prints 2
    //free(h->next->next);
    //free(h->next);
    free(h);

   // struct node* h1 = buildList();
    printf("The element is %d\n", h->next->data);  //print 2 ?? why?
    return 0;
}

Beide Drucke 2. Sollte nicht kostenlos (h) anrufen, h entfernen. Wenn ja warum stehen diese h-> nächsten-> Daten zur Verfügung, wenn h frei ist. Natürlich wird der 'zweite' Knoten nicht freigegeben. Da der Kopf jedoch entfernt wird, sollte er auf das nächste Element verweisen können. Was ist der Fehler hier? 

clinked-listheap-memory
21
user235273

Eine iterative Funktion, um Ihre Liste freizugeben:

void freeList(struct node* head)
{
   struct node* tmp;

   while (head != NULL)
    {
       tmp = head;
       head = head->next;
       free(tmp);
    }

}

Was die Funktion tut, ist folgendes:

  1. prüfen Sie, ob head NULL ist. Wenn ja, ist die Liste leer und wir kehren zurück

  2. Speichern Sie die Variable head in einer Variable tmp und machen Sie head auf den nächsten Knoten in Ihrer Liste (dies geschieht in head = head->next).

  3. Jetzt können wir die Variable free(tmp) sicher verwenden und head zeigt nur auf den Rest der Liste. Gehen Sie zurück zu Schritt 1 
45
insumity

Einfach durch die Liste durchlaufen:

struct node *n = head;
while(n){
   struct node *n1 = n;
   n = n->next;
   free(n1);
}
3
elcuco

Du könntest es immer rekursiv so machen:

void freeList(struct node* currentNode)
{
    if(currentNode->next) freeList(currentNode->next);
    free(currentNode);
}
1
Bradley Swain

Eine Funktion kann die Arbeit erledigen,

void free_list(node *pHead)
{
    node *pNode = pHead, *pNext;

    while (NULL != pNode)
    {
        pNext = pNode->next;
        free(pNode);
        pNode = pNext;
    }

}
0
Mehul