C语言单链表中插入与遍历函数参数指针差异原因咨询

Great question—this is one of the most common "aha!" moments when learning linked lists in C, so let’s unpack it step by step.

First, remember this golden rule about C: all function arguments are passed by value. That means when you pass a variable to a function, the function gets a copy of that variable. Changes to the copy don’t affect the original variable outside the function.

Let’s break down the two cases:

1. Display function (void display_list(struct Node* head)) #

The display function only needs to traverse the list and read the data in each node. It never needs to change where the original head pointer points.

When you pass head (a single pointer) to display_list, the function gets a copy of that pointer. But since both the original and the copy point to the same first node, the function can follow the next pointers to iterate through the entire list perfectly fine. No need to modify the original head here—so a single pointer is all you need.

2. Insert function (void insert_element(struct Node** head, int element)) #

The insert function often needs to modify the original head pointer itself. Let’s take the most obvious example: inserting the first node into an empty list.

If you tried to use a single pointer for the insert function:

void insert_element(struct Node* head, int element) {
    struct Node* new_node = malloc(sizeof(struct Node));
    new_node->data = element;
    new_node->next = NULL;
    head = new_node; // This only changes the COPY of head inside the function
}

When you call this function with insert_element(head, 5), the original head variable (which was NULL) stays NULL. The function modified its own copy of head, not the one in your main code. That’s a bug—your list would still be empty after calling this!

By using a double pointer (struct Node** head), you’re passing the address of the original head pointer to the function. Now, the function can dereference that double pointer to access and modify the original head variable directly:

void insert_element(struct Node** head, int element) {
    struct Node* new_node = malloc(sizeof(struct Node));
    new_node->data = element;
    new_node->next = *head; // Point new node to the old head
    *head = new_node; // Update the ORIGINAL head pointer to point to the new node
}

When you call this with insert_element(&head, 5), you’re giving the function the location of your head variable. The *head = new_node line changes the value of the original head in your main code—exactly what you need to update the list’s starting point.

This same logic applies to operations like deleting the head node: you need to change where the original head points, so you need a double pointer to modify it.

Your Guess Was Spot-On! #

You’re exactly right—this difference comes down to whether the function needs to modify the pointer itself (insert/delete operations that change the head) or just use the pointer to access the list (display, search, etc.).

内容的提问来源于stack exchange，提问作者SoLow