Printing doubly linked list in C goes into infinite loop

Question

Im trying to learn doubly linked lists. I used the following to print:

typedef struct Node{
    int data;
    struct Node* prev;
    struct Node* next;
}node;

typedef struct List{
    node *head; 
}list;

node * createNode(int data) {
    node * newNode = (node*)malloc(sizeof(node));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}

_Bool isEmpty(const list *L)
{
    if (L->head == NULL)
        return 1;
    return 0;
}

_Bool insert(list *L, node *N) {
    if(isEmpty(L)) { 
        L->head = N;
    }
    else{
        L->head->prev = N; 
        N->next = L->head; 
        L->head = N; 
    }
    if (L->head==N)
        return 1;
    return 0;
}

void _print(list *L){
    node *temp=L->head;
    while(temp!=NULL){
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");
}

int main(int argc, char *argv[]){
    list *L1=(list *)malloc(sizeof(list));

    node *N1=createNode(3);
    node *N2=createNode(1);
    node *N3=createNode(5);

    insert(L1, N3);
    insert(L1, N2);
    insert(L1, N1);
    _print(L1);

}

for reference my list struct only contains a pointer "head" and my node struct contains next, prev and data.

It prints the correct data but goes into infinite loop.
What is the reason?

Answer 1

The problem is that this line in main :

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

Allocates memory for the list , but does not initialize it .

Without initialization the value of L1->head can be anything. And if it happens to be different than 0 (ie NULL ), insert will interpret it as pointing to a valid node (which it isn't).

The result is undefined behavior ( UB ), which means anything can happen. It might seem to work, it can crash, or get into an infinite loop etc.

In order to fix it, you need to initialize the list pointed by L1 .
You can do it at least in 2 ways:

1. Replace the call to malloc with calloc , which also zeroes the allocated memory:

    list* L1 = (list*)calloc(sizeof(list), 1);

2. Add an explicit initialization after the malloc :

    list* L1 = (list*)malloc(sizeof(list)); L1->head = NULL; /* <--- initialization */

   You can also add a function for encapsulating the initialization.