Question

So I have a self-made double-linked-list implementation that is being used as a stand in for a queuer. (implemented in C, a language that I am admittedly weak in).

my typedef for the node:

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

which says “a node has a name, a datapoint, whether it’s recurring or not and pointers to the previous and next nodes”

the insertion function like so

node * insertFromTail(node *tail, int data, int recurring, char *name)
{
    node *newNode;
    node *oldNext;
    node *origTail = tail;
    /*assume *pointer points to tail of list*/
    /*printf("tail data is %d\n", tail->data);
    printf("before loop\n");*/
    while(tail->prev != NULL && tail->data > data)
    {
        /*printf("inside while loop\n");*/
        tail = tail -> prev;
    }
    /*printf("after loop\n");*/
    /*if we are looking at a no item list or tail*/
    if(tail->next == NULL)
    {
        /*printf("pointer is tail\n");*/
        return insert(tail, data, recurring, name);
    }
    else /*tail pointer points at item before the point of insertion*/
    {
        /*printf("default case\n");
        printf("pointer data is %d\n", tail->data);*/
        oldNext = tail->next;
        newNode = (node *)malloc(sizeof(node));
        newNode->data = data;
        newNode->recurring = recurring;
        newNode->name = name;
        oldNext -> prev = newNode;
        newNode -> next = oldNext;
        tail -> next = newNode;
        newNode -> prev = tail;
        return origTail;
    }
}

with the internal insert

node * insert(node *tail, int data, int recurring, char *name)
{
        /* Allocate memory for the new node and put data in it.*/
        tail->next = (node *)malloc(sizeof(node));
        (tail->next)->prev = tail;
        tail = tail->next;
        tail->data = data;
        tail->recurring = recurring;
        tail->name = name;
        tail->next = NULL;
        return tail;
}

which is passed the tail of the list, the data point, the time at which the next item will recur at and the name of the item.

if we start with a node that is empty and has NULL prev and next references (a dummy node), and I add three unique nodes with a function called ADD that calls insertFromTail taking input from stdIn

int main()
{
    node *start,*temp,*tail;
    start = (node *)malloc(sizeof(node));
    temp = start = tail;
    temp->next = NULL;
    temp->prev = NULL;
    if(strcmp(command, "ADD") == 0)
    {
        scanf("%d",&argTime);
        scanf("%s",&argName);
        tail = insertFromTail(head, argTime, 0, *argName);
    }
}

with input as so:

INPUT: 
ADD 10 Gin
ADD 20 Vodka
ADD 30 Rum
PRINT

I would get an output of

OUTPUT:
Rum 10
Rum 20
Rum 30

This is an error, as the desired output would be
OUTPUT:
Gin 10
Vodka 20
Rum 30

I have a feeling it has to do with how the string is passed into the node, but as you can see, I’m stumped. This is the last thing left on the assignment and everything else is working perfectly, so I decided to ask here to see if anyone can nudge me on the right path. Thanks for your help in advance 🙂

P.S. Sorry for bad everything, I’m sleep deprived 🙁

Answer 1

Short answer: you’ll need to duplicate that name:

tail->name = strdup(name);

Longer answer: at each iteration you’re storing the same pointer. You’re storing it and then the next time you’re writing to it again. So you end up with 3 identical pointers to whatever you input last.

A simple fix is to duplicate the string and store a copy: precisely what strdup does. But if your implementation lacks strdup, you can try:

tail->name = malloc(strlen(name) + 1);
strcpy(tail->name, name);

• Don’t forget to check for errors
• Don’t forget to free the memory at some point