关于实现多链表

Question

我正在做一个类似于通讯录的项目。首先，我们在一个文本文件中有许多学生。我将实现一个多链表，该列表有 2 个头+尾指针（名称、姓氏的头+尾指针）。这些指针显示相同的列表但位置不同，因为我按升序添加节点并使用双指针向后打印列表。问题是我通过按姓名和姓氏添加节点来实现列表，当我插入另一个节点时操作成功。但是我意识到，当我按她/他的“姓名”删除一个节点并再次打印列表时，学生不存在，但是当我按“姓”打印列表时，学生确实存在。然后我意识到我实现了两个单独的链表。我被告知只实现一个添加和删除功能。但是如何通过名字指针和姓氏指针一起添加节点呢？我希望我可以理解地解释我的问题。这是我的代码块。

我的结构：

typedef struct node {
    int birth_date;
    int zipcode;
    int phone_num;
    char first_name[50];
    char last_name[50];
    char city[50];
    char address[50];
    char email_addr[50];

    struct node* fn_next;
    struct node* fn_pre;
    struct node* ln_next;
    struct node* ln_pre;
    struct node* birdat_next;
    struct node* birdat_pre;
} NODE;

typedef struct {
    int fn_count;
    int ln_count;

    NODE* fn_head;
    NODE* ln_head;

    NODE* fn_tail;
    NODE* ln_tail;
}LIST;

我逐行读取文件并调用添加函数的代码块：

while ( !feof(myfile) ) {
    NODE* pnew_stu;

    if( !(pnew_stu = (NODE*) malloc(sizeof(NODE))) ) {
        printf("ERROR NOT ENOUGH MEMORY!!!\n");
        exit(100);
    }

    fscanf(myfile,"%s", &(pnew_stu->first_name) );
    fscanf(myfile,"%s", &(pnew_stu->last_name) );
    fscanf(myfile,"%s", &(pnew_stu->email_addr) );
    fscanf(myfile,"%d", &(pnew_stu->phone_num) );
    fscanf(myfile,"%s", &(pnew_stu->address) );
    fscanf(myfile,"%s", &(pnew_stu->city) );
    fscanf(myfile,"%d", &(pnew_stu->zipcode) );

    add_Node(list,pnew_stu);
}

最后是我的添加函数：

void add_fn_Node(LIST* list, NODE* pnew_stu) {
    NODE* temp = list->fn_head;

    if( list->fn_head == NULL ) {
        pnew_stu->fn_next = list->fn_head;
        pnew_stu->fn_pre = list->fn_head;

        list->fn_head = pnew_stu;
        list->fn_count = 1;
        return;
    }
    else {
        if ( (strcmp( pnew_stu->first_name, temp->first_name )) <= 0 ) { // Basa Ekleme Kosulu
            pnew_stu->fn_next = temp;
            pnew_stu->fn_pre = temp->fn_pre;
            temp->fn_pre = pnew_stu;

            list->fn_head = pnew_stu;
            list->fn_count++;   
            return;
        }
        else {
            while ( temp->fn_next != NULL ) { // Ortaya Ekleme Kosulu
                if ( (strcmp( pnew_stu->first_name, temp->first_name ) >= 0 ) && (strcmp( pnew_stu->first_name, temp->fn_next->first_name) < 0)) {
                    pnew_stu->fn_next = temp->fn_next;
                    pnew_stu->fn_pre = temp;
                    temp->fn_next->fn_pre = pnew_stu;
                    temp->fn_next = pnew_stu;

                    list->fn_count++;
                    return;
                }

                temp = temp->fn_next;
            }
            if ( temp->fn_next == NULL ) { // Sona Ekleme Kosulu
                temp->fn_next = pnew_stu;
                pnew_stu->fn_pre = temp;
                pnew_stu->fn_next = NULL;

                list->fn_tail = pnew_stu;
                list->fn_count++;
                return;
            }
        }
    }
}

void add_ln_Node(LIST* list, NODE* pnew_stu) {
    NODE* temp = list->ln_head;

    if( list->ln_head == NULL ) {
        pnew_stu->ln_next = list->ln_head;
        pnew_stu->ln_pre = list->ln_head;

        list->ln_head = pnew_stu;
        list->ln_count = 1;
        return;
    }
    else {
        if ( (strcmp( pnew_stu->last_name, temp->last_name )) <= 0 ) { // Basa Ekleme Kosulu
            pnew_stu->ln_next = temp;
            pnew_stu->ln_pre = temp->ln_pre;
            temp->ln_pre = pnew_stu;

            list->ln_head = pnew_stu;
            list->ln_count++;
            return;
        }
        else {
            while ( temp->ln_next != NULL ) { // Ortaya Ekleme Kosulu
                if ( (strcmp( pnew_stu->last_name, temp->last_name ) >= 0 ) && (strcmp( pnew_stu->last_name, temp->ln_next->last_name) < 0)) {
                    pnew_stu->ln_next = temp->ln_next;
                    pnew_stu->ln_pre = temp;
                    temp->ln_next->ln_pre = pnew_stu;
                    temp->ln_next = pnew_stu;

                    list->ln_count++;

                    return;
                }
                temp = temp->ln_next;
            }
            if ( temp->ln_next == NULL ) { // Sona Ekleme Kosulu
                temp->ln_next = pnew_stu;
                pnew_stu->ln_pre = temp;
                pnew_stu->ln_next = NULL;

                list->ln_tail = pnew_stu;

                list->ln_count++;

                return;
            }
        }
    }
}

我的删除功能：

void del_fn_name(LIST* list, char* str_key) {
    NODE* temp;

    int num,counter=1,flag;

    temp = list->fn_head;

    if( list->fn_head == NULL ) {
        printf("The list is EMPTY!!!\n");
        return;
    }

    flag = search_fn(list,str_key);

    if ( flag ) {
        printf("Enter the number of student you want to delete : ");
        scanf("%d", &num);

        if( strcmp( list->fn_head->first_name, str_key ) == 0 ) { // Bastan Silme Kosulu
            if( num == counter ) {
                list->fn_head->fn_next->fn_pre = list->fn_head;
                list->fn_head = list->fn_head->fn_next;
                free(list->fn_head);

                printf("%s is deleted and the new header is %s\n", str_key, list->fn_head->first_name );
                return;
            }
            counter++;
        }
        temp = temp->fn_next;

        while ( temp->fn_next != NULL ) {
            if( strcmp( temp->first_name, str_key ) == 0 ) {
                if( num == counter ) {
                    temp->fn_pre->fn_next = temp->fn_next;
                    temp->fn_next->fn_pre = temp->fn_pre;
                    free(temp);
                    printf("%s deleted at between %s  and  %s\n", str_key, temp->fn_pre->first_name, temp->fn_next->first_name);
                    return;
                }
                counter++;
            }
            temp = temp->fn_next;
        }

        if( temp->fn_next == NULL ) { // Sondan Silme Kosulu
            if( strcmp(temp->first_name, str_key) == 0 ) {
                if( num == counter ) {
                    list->fn_tail = temp->fn_pre;
                    temp->fn_pre->fn_next = NULL;
                    free(temp);
                    printf("%s deleted at the end and new tail is %s \n", str_key, list->fn_tail->first_name );
                    return;
                }
            }
        }
    }

void del_ln_name(LIST* list, char* str_key) {
    NODE* temp;
    int num,counter=1,flag;
    temp = list->ln_head;

    if( list->ln_head == NULL ) {
        printf("The list is EMPTY!!!\n");
        return;
    }

    flag = search_ln(list,str_key);

    if ( flag ) {
        printf("Enter the number of student you want to delete : ");
        scanf("%d", &num);

        if( strcmp( list->ln_head->last_name, str_key ) == 0 ) { // Bastan Silme Kosulu
            if( num == counter ) {
                temp->ln_next->ln_pre = list->ln_head;
                list->ln_head = temp->ln_next;
                free(temp);

                printf("%s is deleted and the new header is %s\n", str_key, list->ln_head->last_name );
                return;
            }
            counter++;
        }
        temp = temp->ln_next;
        while ( temp->ln_next != NULL ) {
            if( strcmp( temp->last_name, str_key ) == 0 ) {
                if( num == counter ) {
                    temp->ln_pre->ln_next = temp->ln_next;
                    temp->ln_next->ln_pre = temp->ln_pre;
                    free(temp);

                    printf("%s deleted at between %s  and  %s\n", str_key, temp->ln_pre->last_name, temp->ln_next->last_name);
                    return;
                }
                counter++;
            }
            temp = temp->ln_next;
        }

        if( temp->ln_next == NULL ) { // Sondan Silme Kosulu
            printf("The last item %s second last item %s\n", temp->first_name, list->fn_tail->fn_pre->first_name);*/
            if( strcmp(temp->last_name, str_key) == 0 ) {
                if( num == counter ) {
                    list->ln_tail = temp->ln_pre;
                    temp->ln_pre->ln_next = NULL;
                    free(temp);

                    printf("%s deleted at the end and new tail is %s \n", str_key, list->ln_tail->last_name );
                    return;
                }
            }
        }
    }

整数flag 和counter 用于删除重复的学生。例如，如果有三个重复项，它会询问我要删除的学生人数。因此，如果我输入数字 2，它会删除第二个重复项。

Answer 1

打印(搜索(type="cliente", codice=random.randrange(1000))) print(find(type="cliente", 代码=random.randrange(1000))) 导入系统 sys.exit(1)

您的代码似乎有点复杂，但想法是正确的。我在插入方法中没有看到任何错误，但是很难遵循所有这种复制粘贴程序。您可以同时将每个学生放在几个不同的列表中，但我建议使用不同的方法来避免所有这些重复，这样很容易引入错误。

数据结构

你可以抽象出链接和列表的概念：

typedef struct TList
{
    struct TLink *first, *last;
} List;

typedef struct TLink
{
    struct TStudent *student;
    struct TLink *prev, *next;
} Link;

List 结构是您需要的三个列表中的任何一个（名字、姓氏、生日），Link 是任何链接。见下图……

使用这种方法，用于在列表中插入/删除链接的代码与所有链接类型（first_name、last_name、age）共享。付出的代价是每个链接都多了一个指针，需要写link->student->first_name而不是link->first_name。

链接插入/删除

向列表添加链接类似于

// Adds a new link before the link `before` or as last link
// if `before` is NULL
void addLink(List *list, Link *newlink, Link *before)
{
    newlink->next = before;
    newlink->prev = before ? before->prev : list->last;
    if (newlink->next) newlink->next->prev = newlink;
                  else list->last = newlink;
    if (newlink->prev) newlink->prev->next = newlink;
                  else list->first = newlink;
}

从列表中删除链接类似于

void removeLink(List *lists, Link *link)
{
    if (link->next) link->next->prev = link->prev;
               else list->last = link->prev;
    if (link->prev) link->prev->next = link->next;
               else list->first = link->next;
}

这两个函数可用于管理所有三种类型（名字、姓氏和年龄）的列表/链接，无需任何代码重复。

学生对象的插入

通过这种方法，学生对象可以拥有所有数据和许多链接对象

typedef struct TStudent
{
    char first_name[NAMESIZE];
    char last_name[NAMESIZE};
    int age;
    Link first_name_link, last_name_link, age_link;
} Student;

例如为了first_name列表插入学生，代码变成

Student *newstudent = ...
...
Link *before = first_name_list.first;
while (before != NULL &&
       strcmp(newstudent->first_name,
              before->student->first_name) > 0)
{
    before = before->next;
}
addLink(&first_name_list,
        &newstudent->first_name_link,
        before);

请注意，这个简单的循环可以正确处理所有在您的代码中通过复制粘贴类似语句单独处理的情况（这是插入的第一个学生，最后一个，中间一个）。

这里的想法是将before 节点设置为列表中的第一个节点，如果必须在后面插入新节点，则继续将其移动到下一个学生。

当然，在其他两个列表（last_name_list 和age_list）中找到正确的插入点需要相同类型的循环。使用函数指针也可以排除插入点搜索。

删除学生对象

要删除Student，当然必须从所有列表中删除学生数据，换句话说，必须删除所有三个链接。然而，这仅仅意味着调用 removeLink 函数的 3 次：

 removeLink(&first_name_list, &student->first_name_link);
 removeLink(&last_name_list, &student->last_name_link);
 removeLink(&age_list, &student->age_link);
 free(student);

Answer 2

在 C++ 中，惯用的答案就是使用 Boost.MultiIndex。这完全是为了添加具有各种访问路径（索引）的元素并保持所有索引同步。

但是，如果您希望重新实现这个世界，并且您仅限于 C（因为到目前为止您提供的所有代码都是 C，尽管有标签），那么我不知道有任何库可以提供这个。

一般来说，这个想法很简单，特别是如果一个简单的列表就足够了。正如您在节点中所指出的那样，您只需要按您希望保留节点的索引的上一个/下一个对。

现在，添加节点时，首先需要分配它，然后在每个索引中定位插入点。如果全部都找到了，并且没有发生错误，那么你将它插入到每个索引中的定位点，现在该结构负责管理内存。

同样，在删除节点时，首先需要定位节点本身，然后将其从每个索引中删除。然后要么将它返回给调用者（pop-like），要么自己释放它。

Answer 3

这应该可行：

void add_Node(LIST* list,NODE* pnew_stu){
    add_fn_Node(list,pnew_stu);
    add_ln_Node(list,pnew_stu);
}

void remove_Node(LIST* list, NODE* pdead_stu){
    if(pdead_stu->fn_next){
        pdead_stu->fn_next->fn_pre=pdead_stu->fn_pre;
    }
    if(pnew_stu->fn_pre){
        pdead_stu->fn_pre->fn_next=pdead_stu->fn_next;
    }
    if(pnew_stu->ln_next){
        pdead_stu->ln_next->ln_pre=pdead_stu->ln_pre;
    }
    if(pnew_stu->ln_pre){
        pdead_stu->ln_pre->fn_pre=pdead_stu->ln_next;
    }
    if(list->fn_head==pdead_stu){list->fn_head=pdead_stu->fn_next;}
    if(list->ln_head==pdead_stu){list->ln_head=pdead_stu->ln_next;}
    if(list->fn_tail==pdead_stu){list->fn_tail=pdead_stu->fn_pre;}
    if(list->ln_tail==pdead_stu){list->ln_tail=pdead_stu->ln_pre;}
    list->fn_count--;
    list->ln_count--;
}