C语言链表指针复制方法及头插法无限循环问题求解

你的代码出现无限循环的核心原因是重复复用栈上的同一个局部节点变量，导致链表节点形成自引用闭环，具体分析和修复方案如下：

问题根源 #

在case 1分支中，你定义的struct node new;是栈上的局部变量，每次进入该分支时，这个变量会被分配到栈内存的同一地址：

• 第一次插入元素2时，new的地址被赋值给head，new.next指向NULL，此时链表是[2] -> NULL。
• 第二次插入元素3时，复用了同一个栈地址的new，将其val设为3，next指向之前的head（也就是这个new自己的地址），此时节点的next指向自身，形成闭环。打印链表时，遍历指针永远无法到达NULL，因此无限输出3。

你尝试的指针复制操作（比如&*head、*new.next=*head）都没解决本质问题——你需要的是每个节点拥有独立的内存空间，而不是复用同一个栈变量。

修复方案 #

每次插入节点时，使用malloc从堆内存动态分配新节点，确保每个节点都是独立的内存块：

修改后的核心代码 #

#include <stdio.h>
#include <stdlib.h> // 引入malloc/free所需的头文件

struct node{
    int val;
    struct node *next;
};

struct node * insertathead(struct node * head,int ele,struct node * new){
    new->val=ele;
    new->next=head;
    return new;
}

int main(){
    struct node *head=NULL;
    struct node *tail=NULL;
    int len=0;
    while(1){
        int k=0,k1=0,ele;
        printf("Welcome to linked list interface!\nWhat would you like to do?\n1. Insert\n2. Delete\n3. Print all elements\n4. Exit\n");
        scanf("%d",&k);
        if (k==4){
            break;
        }
        switch(k){
            case 1:
                printf("Where would you like to insert? (Enter 0 or -1 for head or tail resp) : ");
                scanf("%d",&k1);
                if (k1>len){
                    printf("Index Error\n");
                    break;
                }
                printf("Enter the element: ");
                scanf("%d",&ele);
                // 动态分配新节点，检查内存分配是否成功
                struct node *new_node = (struct node*)malloc(sizeof(struct node));
                if (new_node == NULL) {
                    printf("Memory allocation failed\n");
                    break;
                }
                if (k1==0){
                    head=insertathead(head,ele,new_node);
                    // 第一个节点插入时，同步更新tail
                    if (len == 0) {
                        tail = new_node;
                    }
                } else if (k1 == -1) {
                    // 补充实现表尾插入逻辑
                    new_node->val = ele;
                    new_node->next = NULL;
                    if (tail != NULL) {
                        tail->next = new_node;
                    } else {
                        // 空链表时插入尾节点，head也要更新
                        head = new_node;
                    }
                    tail = new_node;
                }
                len+=1;
                break;

            case 3:
                struct node *k2=head;
                if (len==0){
                    printf("Underflow\n");
                } else {
                    while(k2!=NULL){
                        printf("%d\n",k2->val);
                        k2=k2->next;
                    }
                }
                break;

            case 2:
                printf("Delete function not implemented yet\n");
                break;
        }
    }

    // 程序退出前释放链表内存，避免内存泄漏
    struct node *temp;
    while (head != NULL) {
        temp = head;
        head = head->next;
        free(temp);
    }
    return 0;
}

关键修改点 #

1. 引入<stdlib.h>头文件，用于malloc和free函数。
2. 用struct node *new_node = (struct node*)malloc(sizeof(struct node))动态分配节点，每个节点拥有独立的堆内存。
3. 补充了表尾插入的逻辑，完善你原本的需求。
4. 程序退出前遍历链表释放所有节点，避免内存泄漏。

关于链表指针复制 #

链表指针本身是内存地址，复制指针（比如ptr2 = ptr1）只是复制地址值，并不会复制指针指向的节点内容。如果需要复制整个链表（深拷贝），需要遍历原链表，为每个节点动态分配新内存并复制值；如果只是传递节点地址（浅拷贝），直接赋值指针即可，但要注意内存的生命周期（比如不能用栈上局部变量的地址作为链表节点，因为栈变量会被销毁）。

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