I implemented a linked list for my school assignment but when I try to print out value of a node, the first node always get printed with memory address and I can't figure out why it's happening. 

I tried debugging and as I assign tail of list to the new node, the value of the node gets printed out as memory address.

Why is this happening?

int AppendLinkedList(LinkedListPtr list, int value) {
    LinkedListNodePtr newNode = CreateLinkedListNode(value);
    if (list->head == NULL) {
        list->head = newNode;
        list->tail = newNode;
        
        return 0;
    }
    LinkedListNodePtr tailCopy = list->tail;
    newNode->prev = tailCopy;
    tailCopy->next = newNode;
    list->tail = newNode;
    return 0;
}

LinkedListNode *CreateLinkedListNode(int data) {
    LinkedListNodePtr newNode;
    newNode = (LinkedListNodePtr)malloc(sizeof(LinkedListNode));
    newNode->data = data;
    printf("%d\n", data);
    return newNode;
}

int main() {
    LinkedListPtr list = CreateLinkedList();
    int data = 5;
    AppendLinkedList(list, data);
}

typedef struct ll_node {
    int           data;       // Data this node holds 
    struct ll_node *next;     // next node in list, or NULL
    struct ll_node *prev;     // prev node in list, or NULL
} LinkedListNode, *LinkedListNodePtr;

typedef struct ll_head {
    uint64_t          num_elements;  //  # elements in the list
    LinkedListNodePtr head;  // head of linked list, or NULL if empty
    LinkedListNodePtr tail;  // tail of linked list, or NULL if empty
} *LinkedListPtr;

LinkedListPtr CreateLinkedList() {
    LinkedListPtr list;
    list = (LinkedListPtr)malloc(sizeof(LinkedListPtr));
    if (list == NULL) {
        return NULL;
    }
    return list;
} 

CodePudding user response：

There are multiple problems in your code:

• you do not initialize the prev and next members to NULL in CreateLinkedListNode().

• the allocation size is incorrect in CreateLinkedList(): you should use:

  LinkedList *list = malloc(sizeof(*list));

and you should initialize the members num_elements to 0 and head and tail to NULL.

• the order of definitions is inadequate and the header files are missing.

• AppendLinkedList() does not update num_elements.

More generally, hiding pointers behind typedefs is error prone. The code is much more readable with the explicit pointer syntax.

Here is a modified version:

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

typedef struct ll_node {
    int           data;      // Data this node holds 
    struct ll_node *next;    // next node in list, or NULL
    struct ll_node *prev;    // prev node in list, or NULL
} LinkedListNode;

typedef struct ll_head {
    uint64_t  num_elements;  //  # elements in the list
    LinkedListNode *head;    // head of linked list, or NULL if empty
    LinkedListNode *tail;    // tail of linked list, or NULL if empty
} LinkedList;

LinkedList *CreateLinkedList() {
    LinkedList *list = malloc(sizeof(*list));
    if (list != NULL) {
        list->num_elements = 0;
        list->head = NULL;
        list->tail = NULL;
    }
    return list;
} 

LinkedListNode *CreateLinkedListNode(int data) {
    LinkedListNode *newNode = malloc(sizeof(*newNode));
    if (newNode != NULL) {
        newNode->data = data;
        newNode->prev = NULL;
        newNode->next = NULL;
    }
    return newNode;
}

int AppendLinkedList(LinkedList *list, int value) {
    if (list == NULL)
        return -1;

    LinkedListNode *newNode = CreateLinkedListNode(value);
    if (newNode == NULL)
        return -1;

    if (list->head == NULL) {
        list->head = newNode;
    } else {
        LinkedListNode *tail = list->tail;
        newNode->prev = tail;
        tail->next = newNode;
    }
    list->tail = newNode;
    list->num_elements  = 1;
    return 0;
}

int main() {
    LinkedList *list = CreateLinkedList();
    int data = 5;
    AppendLinkedList(list, data);
}