C语言单链表Segmentation fault:11问题：单元素输入后触发报错

Hey there! Let's figure out why that segmentation fault is popping up when you only enter one element followed by -1. This kind of issue almost always boils down to a null pointer access—your code is trying to read or write to a memory address that doesn't exist (usually because a pointer is pointing to NULL when you don't expect it to).

Most Likely Causes & Fixes #

Let's break down the common scenarios that trigger this exact problem:

1. Your end-condition logic is mishandling the first -1

The requirement is to stop when the user enters -1 twice in a row. If your code isn't tracking the previous input separately (and instead tries to use the last linked list node's data to check), you could run into trouble. For example:

• If you input 1 then -1, your code might incorrectly try to compare -1 to the last node's data (which is 1), then accidentally add -1 to the list. But if your code then tries to do something with that new node (like access next when it's not properly initialized), that's a crash waiting to happen.

Fix: Track the previous input with a separate variable, not the linked list. Here's a clean example of the end-condition logic:

typedef struct Node {
    int data;
    struct Node *next;
} Node;

int main() {
    int prev_input = 0; // Initialize to a non--1 value
    int curr_input;
    Node *head = NULL, *tail = NULL;

    while (1) {
        printf("Enter an integer: ");
        scanf("%d", &curr_input);

        // Check for consecutive -1s first
        if (prev_input == -1 && curr_input == -1) {
            break;
        }

        // Only add non--1 values to the list
        if (curr_input != -1) {
            Node *new_node = malloc(sizeof(Node));
            new_node->data = curr_input;
            new_node->next = NULL;

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

        // Update previous input for next iteration
        prev_input = curr_input;
    }

    // Example: Print the list to verify
    Node *current = head;
    printf("Your list: ");
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");

    // Cleanup memory
    current = head;
    while (current != NULL) {
        Node *temp = current;
        current = current->next;
        free(temp);
    }
    return 0;
}

2. Linked list operations have edge-case bugs for single-node lists

When your list only has one node, operations like traversal, cleanup, or tail management can go wrong if you don't check for NULL properly. For example:

• If you try to access current->next when current is the last node (so next is NULL), then try to read current->next->data, that's an immediate segmentation fault.
• If your tail pointer isn't set correctly for a single node (e.g., tail is NULL instead of pointing to the head), any attempt to use tail will crash.

Fix: Add explicit NULL checks in all your linked list functions. For example, a safe cleanup function:

void free_list(Node *head) {
    Node *temp;
    while (head != NULL) { // Stop before head becomes NULL
        temp = head;
        head = head->next;
        free(temp);
    }
}

3. You're adding -1 to the list by mistake

If your code adds the first -1 to the list (instead of just using it to check for the end condition), you might end up with a node containing -1 that your code doesn't handle correctly later. While this might not cause a crash directly, it can lead to unexpected behavior that triggers other bugs.

Debugging Tip to Find the Exact Line #

If you're still stuck, use gdb to pinpoint the crash:

1. Compile your code with debug symbols: gcc -g your_code.c -o your_program
2. Run it in gdb: gdb ./your_program
3. Start the program: run
4. Enter your test case (1 then -1)
5. When it crashes, type bt (backtrace) to see exactly which line of code caused the segmentation fault. This will tell you exactly where the null pointer access is happening.

内容的提问来源于stack exchange，提问作者Pedro Rossini Sardelich