Thread: How to create many nodes in list

The problem is that if you're only keeping track of the head, it's rather inefficient to append to the linked list in a loop as you have to keep traversing the entire linked list on each iteration.

The solution is to keep track of both head and tail. Initially, they are both null pointers. When the very first node is added, the head and tail pointers both point to that on. On the second and subsequent nodes, the tail node's next pointer is set to point to the new node (with a null next pointer, of course), and then the tail pointer itself is set to point to the new node, thereby appending to the linked list in constant time while keeping track of the tail.

You might want to test your code before posting as from what I can see, the code prefaced by the comment "Makes sure there is a place to start" has bugs because it accesses conductor->next and conductor->x before they have been set with their initial values. Recall that malloc doesn't necessarily zero the memory allocated. Frankly, you can get rid of that part entirely, and likewise the code that searches for the end of the linked list at the start of the loop: you already know for sure that you're at the end.

Keeping to the same output as your example program but with more graceful error checking and without the unnecessary output of the pre-initial-value, what I had in mind was more along these lines:

Code:

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

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

int read_int(int *result)
{
    char buffer[BUFSIZ];
    return fgets(buffer, sizeof(buffer), stdin) && sscanf(buffer, "%d", result) == 1;
}

struct node *linked_list_populate(int n)
{
    struct node *head = NULL;
    struct node *tail = NULL;
    for (int i = 0; i < n; i++)
    {
        struct node *new_node = malloc(sizeof(*new_node));
        if (!new_node)
        {
            fprintf(stderr, "Out of memory\n");
            break;
        }
        new_node->next = NULL;

        if (head)
        {
            tail->next = new_node;
            tail = new_node;
        }
        else
        {
            head = tail = new_node;
        }

        do
        {
            printf("Enter an integer. ");
        }
        while (!read_int(&tail->x));
    }
    return head;
}

void linked_list_print(struct node *head)
{
    while (head)
    {
        printf(" %d ", head->x);
        head = head->next;
    }
}

void linked_list_destroy(struct node *head)
{
    while (head)
    {
        struct node *next = head->next;
        free(head);
        head = next;
    }
}

int main(void)
{
    struct node *head = linked_list_populate(5);

    printf("Show the list:\n");
    linked_list_print(head);
    printf("\nEnd of program\n");

    linked_list_destroy(head);
    return 0;
}

Although I might wrap head and tail in a struct linked_list instead, should it be useful to continue to keep track of the tail after populating the linked list.