What is the reason for using a double pointer when adding a node in a linked list?

by

Some implementations pass a pointer to pointer parameter to allow changing the head pointer directly instead of returning the new one. Thus you could write:

// note that there's no return value: it's not needed
void push(struct node** head, int data)
{
    struct node* newnode = malloc(sizeof(struct node));
    newnode->data=data;
    newnode->next=*head;
    *head = newnode; // *head stores the newnode in the head
}

// and call like this:
push(&head,1);

The implementation that doesn’t take a pointer to the head pointer must return the new head, and the caller is responsible for updating it itself:

struct node* push(struct node* head, int data)
{
    struct node* newnode = malloc(sizeof(struct node));
    newnode->data=data;
    newnode->next=head;
    return newnode;
}

// note the assignment of the result to the head pointer
head = push(head,1);

If you don’t do this assignment when calling this function, you will be leaking the nodes you allocate with malloc, and the head pointer will always point to the same node.

The advantage should be clear now: with the second, if the caller forgets to assign the returned node to the head pointer, bad things will happen.

Edit:

Pointer to pointer(Double pointers) also allows for creation for multiple user defined data types within a same program(Example: Creating 2 linked lists)

To avoid complexity of double pointers we can always utilize structure(which works as an internal pointer).

You can define a list in the following way:

typedef struct list {
    struct node* root;    
} List;

List* create() {
    List* templ = malloc(sizeof(List));
    templ->root = NULL;
    return templ;
}

In link list functions use the above List in following way: (Example for Push function)

void Push(List* l, int x) {         
    struct node* n = malloc(sizeof(struct node));
    n->data = x;
    n->link = NULL;
    
    printf("Node created with value %d\n", n->data);
    if (l->root == NULL) {
        l->root = n;
    } else {
        struct node* i = l->root;
        while (i->link != NULL){
            i = i->link;
        }
        i->link = n;
    }
}

In your main() function declare the list in follow way:

List* list1 = create(); 
push(list1, 10);

More Related Contents:

  1. Using pointers to remove item from singly-linked list
  2. Rationale behind the container_of macro in linux/list.h
  3. Pointers program
  4. Are there differences between pointers to object stored on stack and heap? [closed]
  5. With arrays, why is it the case that a[5] == 5[a]?
  6. Length of array in function argument
  7. What is the difference between char * const and const char *?
  8. In C, are arrays pointers or used as pointers?
  9. Are all data pointers the same size in one platform for all data types? [duplicate]
  10. How do I understand complicated function declarations?
  11. How can I allocate memory and return it (via a pointer-parameter) to the calling function?
  12. Pointer Arithmetic In C
  13. C pointers : pointing to an array of fixed size
  14. Array to pointer decay and passing multidimensional arrays to functions
  15. Why does this code segfault on 64-bit architecture but work fine on 32-bit?
  16. C: Which character should be used for ptrdiff_t in printf?
  17. Why doesn’t scanf need an ampersand for strings and also works fine in printf (in C)?
  18. How to print variable addresses in C?
  19. Returning Arrays/Pointers from a function
  20. why is array name a pointer to the first element of the array?
  21. C – Accessing data AFTER memory has been free()ed?
  22. allocate matrix in C
  23. Passing two-dimensional array via pointer
  24. Getting the size of a malloc only with the returned pointer
  25. Mis-aligned pointers on x86
  26. How to find the size of an array (from a pointer pointing to the first element array)?
  27. Can I treat a struct like an array?
  28. Why do linked lists use pointers instead of storing nodes inside of nodes
  29. Can a “container_of” macro ever be strictly-conforming?
  30. Difference between pointer to pointer and pointer to array?

Leave a Comment