Was ist falsch an dieser verketteten Liste löschen Endknoten-Funktion?

Question

Ich habe diese Funktion geschrieben, um den letzten Knoten einer einfach verketteten Liste zu löschen.

Das Problem ist, es ist in der Lage alle Knoten mit Ausnahme des ersten / Startknoten zu löschen.

Was aus diesem Codefragment fehlt?

Bitte beantworten Sie mein besonderes Problem dar.

    #include <stdio.h>
#include <stdlib.h>

struct Node
{
    char CharContent;
    struct Node * NextNodePointer;
};
typedef struct Node Node;

#pragma region Prototypes
Node * CreateNewNode(char ch);
Node * AddNode(Node * start, Node * newNode);
void DeleteTailNode(Node * start);
void PrintAllNodes(const Node * start);
#pragma endregion Comments

main()
{
    Node * start = NULL;
    Node * newNode = NULL;

    start = AddNode(start, CreateNewNode('A'));
    start = AddNode(start, CreateNewNode('B'));
    start = AddNode(start, CreateNewNode('C'));
    start = AddNode(start, CreateNewNode('D'));
    PrintAllNodes(start);

    DeleteTailNode(start);
    PrintAllNodes(start);
    DeleteTailNode(start);
    PrintAllNodes(start);
    DeleteTailNode(start);
    PrintAllNodes(start);
    DeleteTailNode(start);
    PrintAllNodes(start);
    DeleteTailNode(start);
    PrintAllNodes(start);

    getch();
}

#pragma region Node * CreateNewNode(char ch)
Node * CreateNewNode(char ch)
{
    struct Node * newNode = (struct Node *) malloc(sizeof(struct Node *));

    newNode->CharContent = ch;
    newNode->NextNodePointer = NULL;

    return newNode;
}
#pragma endregion Comment

#pragma region UnifiedAddNode()
Node * AddNode(Node * start, Node * newNode)
{
    Node * copyOfStart = start;

    if(start == NULL)
    {
        return newNode;
    }
    else
    {
        while(copyOfStart->NextNodePointer != NULL)
        {
            copyOfStart = copyOfStart->NextNodePointer;
        }

        copyOfStart->NextNodePointer = newNode;

        return start;
    }
}
#pragma endregion Comment


void DeleteTailNode(Node * start)
{
    Node * prev = NULL;
    Node * current = start;

    while(current->NextNodePointer != NULL)
    {
        prev = current;
        current = current->NextNodePointer;
    }

    free (current);

    if (prev != NULL)
    {
        prev->NextNodePointer = NULL;
    }
}


#pragma region PrintAllNodes()
void PrintAllNodes(const Node * start)
{
    struct Node * tempRoot = start;

    while(tempRoot != NULL)
    {
        printf("%c, ", tempRoot->CharContent);

        tempRoot = tempRoot->NextNodePointer;
    }

    printf("\n");
}
#pragma endregion Comment

Answer 1

Innerhalb CreateNewNode()

struct Node * newNode = (struct Node *) malloc(sizeof(struct Node *));  
                                                                  ^
                                                                  |  

                                                                 Ouch!!

Ändern Sie es an: struct Node * newNode = (struct Node *) malloc(sizeof(struct Node));

EDIT 2

Testlauf hier

Answer 2

Sie sind nicht der Fall Erkennen, wo Start NULL ist, das heißt die Liste leer ist.

Wollen Sie nicht den nächsten Knoten befreien vor es auf NULL einstellen?

Wenn der Startknoten ist der letzte Knoten prev NULL sein wird, wenn die Liste Traversal abgeschlossen ist, aber wenn das passiert Sie löschen die (NULL) start->NextNodePointer, wenn Sie selbst starten löschen.

Versuchen Sie:

void DeleteTailNode(Node *& start)
{
    Node * prev = NULL;
    Node * current = start;

    if (start == NULL)
        return;

    while(current->NextNodePointer != NULL)
    {
        prev = current;
        current = current->NextNodePointer;
    }

    if(current != NULL)
        free(current);

    if(current == start)
        start = NULL;

    if(prev != NULL)
        prev->NextNodePointer = NULL;
}

Answer 3

Wie verstehen Sie, wenn es gelöscht ist oder nicht? Wie ich sehe, ist hier nichts gelöscht .. es ist ein 100% sicher, dass Speicherverlust .. du bist nicht mit frei in DeleteTailNode .. Sie machen nur die zugewiesenen Speicher unaccessible ..

Edit: Aufruf kostenlos (Strom) nach der Schleife. Und es gibt keine Notwendigkeit, von der Prüfung, wenn Strom NULL ist, ist es sicher zu löschen NULL-Zeiger.