C语言有序链表插入时头部被覆盖仅存单个节点问题求助

嘿，我帮你梳理下代码里的几个关键问题，这些应该就是导致你遇到头部被覆盖、链表只显示单个节点的原因，咱们一步步拆解：

1. 变量名不匹配的低级错误 #

你的函数参数是char *cognome, char *nome，但代码里却用name和surname来操作——这不仅会触发编译错误，还会让你根本没把传入的名字/姓氏存到节点里，相当于节点的字符串指针指向了未定义的变量，后续必然引发内存混乱，比如覆盖链表节点数据。

赶紧把代码里的name改成nome，surname改成cognome，保持参数和内部变量名一致。

2. 字符串赋值的致命逻辑错误 #

你现在的字符串处理完全走偏了：

x->name = malloc(strlen(name)*sizeof(char));
x->name = name;

第一行你malloc了一块内存，但第二行直接把传入的字符串指针赋值给x->name，这会导致两个严重问题：

• 刚malloc的内存直接泄漏，因为没有指针再指向它；
• x->name和x->surname实际指向的是传入字符串的原地址，如果传入的是局部变量或临时字符串，后续这些内存被回收后，链表节点就会指向无效内存，表现出各种诡异行为（包括节点数据被覆盖）。

正确的做法是用strcpy把字符串内容复制到malloc的内存里，注意要给字符串末尾的\0留空间，所以malloc的长度应该是strlen(str) + 1：

x->name = malloc(strlen(nome) + 1);
if (x->name == NULL) { free(x); return 0; } // 处理内存分配失败
strcpy(x->name, nome);

x->surname = malloc(strlen(cognome) + 1);
if (x->surname == NULL) { free(x->name); free(x); return 0; }
strcpy(x->surname, cognome);

如果你的编译器支持POSIX标准，也可以用strdup简化代码（它会自动malloc并复制字符串）：

x->name = strdup(nome);
x->surname = strdup(cognome);

但一定要检查strdup的返回值是否为NULL，避免内存分配失败的问题。

3. 未初始化指针的潜在风险 #

你定义了link p;但没有初始化它。虽然大部分情况下，进入循环后只要第一个comparison(t,x)<0成立，p会被赋值，但如果链表只有一个节点且新节点比它大，或者comparison函数返回异常，未初始化的p会指向随机内存，写入时直接破坏链表结构。

建议初始化p为NULL，比如link p = NULL;。

4. 务必检查comparison函数的实现 #

你提到用comparison函数比较节点，但没给出它的代码。如果这个函数的逻辑写反了（比如姓氏和名字的比较顺序搞反，或者返回值不符合约定），会导致插入位置完全错误，比如本该插在尾部的节点被插在头部，直接覆盖原头节点。

正确的comparison实现应该是这样的（符合你说的返回值规则）：

int comparison(link a, link b) {
    int cmp_surname = strcmp(a->surname, b->surname);
    if (cmp_surname != 0) {
        return cmp_surname > 0 ? 1 : -1;
    }
    int cmp_name = strcmp(a->name, b->name);
    return cmp_name > 0 ? 1 : (cmp_name < 0 ? -1 : 0);
}

注意strcmp的返回值是正数/负数/0，要转换成你需要的1/-1/0格式。

修复后的完整代码示例 #

把上面的问题都修复后，你的insertInOrder函数应该是这样的：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct node *link;
struct node{
    char *name;
    char *surname;
    link next;
};

typedef struct list *list_t;
struct list{
    link head;
};

int comparison(link a, link b) {
    int cmp_surname = strcmp(a->surname, b->surname);
    if (cmp_surname != 0) {
        return cmp_surname > 0 ? 1 : -1;
    }
    int cmp_name = strcmp(a->name, b->name);
    return cmp_name > 0 ? 1 : (cmp_name < 0 ? -1 : 0);
}

int insertInOrder (list_t list, char *cognome, char *nome){ 
    if (list == NULL || cognome == NULL || nome == NULL) {
        return 0; // 非法输入判断
    }

    link x = malloc(sizeof(*x));
    if (x == NULL) {
        return 0; // 内存分配失败
    }

    // 复制名字和姓氏
    x->name = malloc(strlen(nome) + 1);
    if (x->name == NULL) {
        free(x);
        return 0;
    }
    strcpy(x->name, nome);

    x->surname = malloc(strlen(cognome) + 1);
    if (x->surname == NULL) {
        free(x->name);
        free(x);
        return 0;
    }
    strcpy(x->surname, cognome);

    x->next = NULL;

    if(list->head == NULL){ 
        list->head = x; 
        return 1; 
    } 

    link t = list->head; 
    link p = NULL; // 初始化p为NULL

    while(t != NULL){ 
        int cmp = comparison(t, x);
        if(cmp < 0){ 
            p = t; 
            t = t->next; 
        } else if(cmp > 0){ 
            if(t == list->head){ 
                x->next = list->head; 
                list->head = x; 
                return 1; 
            } else{ 
                p->next = x; 
                x->next = t; 
                return 1; 
            } 
        } else{ 
            // 节点重复，释放已分配的内存
            free(x->name);
            free(x->surname);
            free(x);
            return 0; 
        } 
    } 
    // 走到这里说明要插在链表尾部
    p->next = x; 
    return 1; 
}

额外小建议 #

• 每次malloc后都要检查返回值是否为NULL，避免程序崩溃；
• 发现节点重复时，记得释放为新节点分配的内存，避免内存泄漏；
• 写一个打印链表的辅助函数，逐个节点输出名字和姓氏，方便测试排查问题。

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