Warum zeigt mein Schwanz immer noch auf Etwas, anstatt auf NULL zu zeigen, nachdem ich die Liste zerstört habe

Question

Also habe ich diesen Code in c geschrieben, der einfache doppelt verknüpfte Listenaufgaben wie die Liste erstellt, einen Knoten nach/vor einem gegebenen aktuellen NODE einfügt , entfernt einen gegebenen aktuellen Knoten und so weiter, aber ich stieß auf dieses Problem, als ich versuchte, die Liste zu zerstören. Was passiert ist, wenn ich die Liste zerstöre, hebt sie alle Knoten richtig auf (zumindest denke ich das, was ich in der Debugger-Uhr sehe), aber wenn ich überprüfe, ob der Kopf- und Endzeiger auf NULL seit den Knoten nein zeigen es existiert länger, der Kopf zeigt auf NULL, aber mein Schwanz zeigt immer noch auf etwas, von dem ich nicht sicher bin, ob es ein Knoten von der Liste ist, der nicht richtig freigegeben wurde oder etwas anderes.

Kann mir jemand sagen, was passiert? Hier ist der relevante Code;

Dies ist die Funktion, die alle Knoten freigibt, so dass die Liste

void DListDestruct(DList* list) { 
DListNode* tempHead = list->head;; 

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

if (list->tail == NULL) { 
    list->size = 0; 
} 


} 


    //Creation of the structs for the list  

typedef struct DListNode_struct { 
    char *str; 
    int blankIndex; 
    int blankLength; 
    struct DListNode_struct *next; 
    struct DListNode_struct *prev; 
} DListNode; 

typedef struct DList_struct { 
    int size; 
    DListNode *head; 
    DListNode *tail; 
} DList; 



/* This creates a new list and initializes the head/tail */ 

void DListConstruct(DList* list) { 

    list->head = NULL; 
    list->tail = NULL; 
    list->size = 0; 

} 


/* inserts newNode after the given currNode */ 

void DListInsertAfter(DList* list, DListNode* currNode, DListNode* newNode) { 

DListNode* sucNode = NULL; 

if (list->head == NULL) { 
    list->head = newNode; 
    list->tail = newNode; 
    list->size = list->size++; 
} 

else if (currNode == list->tail) { 
    list->tail->next = newNode; 
    newNode->prev = list->tail; 
    list->tail = newNode; 
    list->size = list->size++; 
} 

else { 
    sucNode = currNode->next; 
    newNode->next = sucNode; 
    newNode->prev = currNode; 
    currNode->next = newNode; 
    sucNode->prev = newNode; 
    list->size = list->size++; 
} 
} 


/* inserts newNode before the given currNode */ 
void DListInsertBefore(DList* list, DListNode* currNode, DListNode* newNode) { 
DListNode* predNode; 


if (list->head == NULL) { 
    list->head = newNode; 
    list->tail = newNode; 
    list->size = list->size++; 
} 

else if (currNode->prev != NULL) { 
    predNode = currNode->prev; 
    newNode->next = currNode; 
    newNode->prev = predNode; 
    currNode->prev = newNode; 
    predNode->next = newNode; 
    list->size = list->size++; 
} 

else if (currNode->prev == NULL) { 
    newNode->next = currNode; 
    currNode->prev = newNode; 
    list->head = newNode; 
    list->size = list->size++; 
} 

} 

So wieder zu zerstören, warum es ist, dass, wenn ich die Liste zerstören, die DListDestroy Funktion (auf die erste) verwenden, werden alle Knoten werden freigegeben, der Head-Zeiger zeigt auf NULL, aber der Tail-Zeiger zeigt immer noch auf etwas?

Vielen Dank im Voraus!

Answer 1

Das liegt daran, dass das Schwanzstil auf die Adresse des Knotens zeigt, den Sie freigegeben haben, also zeigt es jetzt auf etwas Müll.

Der Kopf zeigt auf wo auch immer "tempHead" zeigt und am Ende der Schleife zeigt es auf Null, weil Sie während des Einfügens Null in den nächsten des letzten Knotens setzen.

Abschließend zeigt der Schwanz auf die Adresse des letzten Knotens, der Müll ist. Der Kopf zeigt auf den nächsten Knoten, der NULL ist.