向链表添加新值时为何覆盖已有内容？循环添加随机值异常排查

嘿，这问题我太熟了！你肯定是在循环里犯了一个经典错误——没有为每个新元素创建独立的节点对象/内存块，而是反复修改同一个对象的内容，然后把它的引用/地址塞到链表里面。

举个例子，假设你用的是C语言，错误代码大概是这样的：

// 错误示例
typedef struct Node {
    int val;
    struct Node* next;
} Node;

Node* head = NULL;
Node temp_node; // 只创建了一个节点！

for(int i=0; i<3; i++){
    temp_node.val = rand()%100;
    printf("Added: %d\n", temp_node.val);
    temp_node.next = head;
    head = &temp_node;
}

这里你只在栈上创建了一个temp_node，每次循环只是改它的val和next，然后把它的地址&temp_node加到链表。但链表的所有节点指针都指向同一个内存位置，最后这个位置的值是最后一次循环生成的随机数，所以打印出来全是最后那个值。

如果是Python，错误逻辑也类似：

# 错误示例
import random

class Node:
    def __init__(self):
        self.val = None
        self.next = None

head = None
temp_node = Node() # 只实例化了一个节点！

for _ in range(3):
    temp_node.val = random.randint(0,99)
    print(f"Added: {temp_node.val}")
    temp_node.next = head
    head = temp_node

同样，你反复修改同一个temp_node的val，链表存的都是这个对象的引用，自然最后全显示最后一次的赋值。

修正方案：每次循环都创建新节点 #

不管用什么语言，核心就是每次循环都为新元素分配独立的内存/实例：

C语言修正版：

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

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

Node* head = NULL;

int main() {
    srand(time(NULL));
    for(int i=0; i<3; i++){
        // 每次循环都动态分配新节点
        Node* new_node = (Node*)malloc(sizeof(Node));
        if(!new_node){
            perror("malloc failed");
            exit(1);
        }
        new_node->val = rand()%100;
        printf("Added: %d\n", new_node->val);
        new_node->next = head;
        head = new_node;
    }

    // 打印链表
    Node* curr = head;
    int count = 1;
    while(curr){
        printf("%d: %d\n", count++, curr->val);
        curr = curr->next;
    }

    // 打印完记得释放内存！
    curr = head;
    while(curr){
        Node* temp = curr;
        curr = curr->next;
        free(temp);
    }
    head = NULL;
    return 0;
}

Python语言修正版：

import random

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

head = None

for _ in range(3):
    # 每次循环都新建Node实例
    new_node = Node(random.randint(0,99))
    print(f"Added: {new_node.val}")
    new_node.next = head
    head = new_node

# 打印链表
curr = head
count = 1
while curr:
    print(f"{count}: {curr.val}")
    curr = curr.next
    count +=1

这样一来，每个节点都有自己独立的内存空间/实例，存储的是各自生成的随机值，打印出来就不会全是最后一个啦！

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