Append an element at the end of a linked-List in C programming

Question

I've been studying linked lists in C and regarding the append function, I came across the following code:

struct node
{
    int data;
    struct node *next;
}*head;   



void append(int num)
{
    struct node *temp,*right;
    temp= (struct node *)malloc(sizeof(struct node));
    temp->data=num;
    right=(struct node *)head;
    while(right->next != NULL){
       right=right->next;
    }
    right->next =temp;
    right=temp;
    right->next=NULL;
}

In order to save a line of code, wouldn't it be possible to just add NULL to the temp's next atribute? like so:

void append(int num)
    {
        struct node *temp,*right;
        temp= (struct node *)malloc(sizeof(struct node));
        temp->data=num;
        temp -> next = NULL;
        right=(struct node *)head;
        while(right->next != NULL){
           right=right->next;
        }
        right->next =temp;
    }

there is no guarantee that the `head` is pointing to the correct list. — BLUEPIXY, Dec 31 '13 at 17:49

score 2 · Answer 1 · edited May 23 '17 at 11:49

Yes you are correct. In-fact I will further reduce the length of code by writing separate function that allocate and intialize data as follows:

struct node * getnode(int date){
    struct node *temp = malloc(sizeof(struct node));
    temp->data = data;
    temp->next = NULL;
    return temp;
}

// assuming list have more than one elements: demo code 
void append(struct node *head, int num){
    struct node *right = head;
    while(right->next != NULL){
       right=right->next;
    }
    right->next = getnode(num);
}

This get node function can be useful in other part of code e.g insertatfist(), insert()

Btw: Don't cast the returned address of malloc() and calloc().

May be you like to write struct node* getnode(int data, struct node* next) function that also set next node address.

call it as:

To insert last node:
```
curt->next = getnode(num, NULL);
```
To insert between curt node and curt->next.
```
curt->next = getnode(num, curt->next);
```

score 1 · Answer 2 · answered Dec 31 '13 at 17:45

It certainly is possible to do it that way in this way, However, I see that the code in the first approach is more readable(very small more) to my eyes. However you aren't going to save much.

But don't try to do these kind of optimizations for all programs, give readability more importance than saving a few lines of code. Reason is that compiler is anyways going to do the optimization.

Joshua Clayton · Answer 3 · 2013-12-31T18:09:43.057

0

If you want to "save lines", you could also use calloc, instead of malloc, which zeros your bytes, but that would be LESS clear.

It does save you a line of code, and it is arguable clearer. I think your proposed code change is an improvement in that it separates creation of the new node from placing it.

If this is production code I would probably let sleeping dogs lie. But while we are all chiming in here is how I would implement the same function.

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

struct node* init_node(int num)
{
    struct node * temp = malloc(sizeof(struct node));
    temp->data = num;
    return temp;
}

void append(struct node* n, struct node* list)
{
    while(list->next != NULL){
       list=list->next;
    }
    list->next =n;
    n->next=NULL;       
}

edited Dec 31 '13 at 18:09

answered Dec 31 '13 at 17:46

Joshua Clayton

1,669
18
29

1

Joshua I think you wanted to write `list->next init_node(num);` in-place of `list->next =n;` – Grijesh Chauhan Dec 31 '13 at 18:14
@GrijeshChauhan No, I would separate them. The calling code would init_node, then append(). It doesn't make much difference for a list of int, but the code will port more nicely to any struct with a next pointer to itself. – Joshua Clayton Dec 31 '13 at 18:21

Append an element at the end of a linked-List in C programming

3 Answers3