迭代法反转链表：我的代码为何陷入无限循环？

核心问题 #

1. 无限循环风险：如果传入循环链表，内层while(temp1->next != NULL)会永远执行（循环链表无尾节点）；即使是正常单链表，你的代码逻辑也存在冗余，且末尾的错误操作会导致程序崩溃而非功能正常。
2. 野指针致命错误：末尾的delete head1完全错误，head1是反转后的新头节点，执行delete后head = head1会让head指向已释放的内存，直接引发程序崩溃。
3. 效率极低：每次遍历找尾节点的方式时间复杂度为O(n²)，长链表下性能极差。
4. 边界处理缺失：未考虑空链表的情况，若传入head == NULL，head->next会直接触发空指针访问错误。

修复当前思路的代码（仅解决功能问题） #

如果要保留「每次取尾节点构建反转链表」的思路，需要调整循环逻辑并删除错误的delete语句：

void rev(node* &head)
{
    if (head == nullptr) return; // 处理空链表
    int flag = 0;
    node* head1 = nullptr;
    node* currHead = head;

    while (currHead != nullptr)
    {
        node* temp1 = currHead;
        node* temp2 = currHead;
        // 找到当前链表的尾节点和前驱节点
        while (temp1->next != nullptr)
        {
            temp2 = temp1;
            temp1 = temp1->next;
        }

        if (flag == 0)
        {
            head1 = temp1;
            flag++;
        }
        // 处理只剩单个节点的情况
        if (temp1 != currHead)
        {
            temp1->next = temp2;
            temp2->next = nullptr;
        }
        else
        {
            temp1->next = nullptr; // 反转后的尾节点
        }
        // 更新当前链表头，终止循环条件
        currHead = (currHead == temp1) ? nullptr : head;
    }
    head = head1;
}

标准高效反转写法（O(n)时间 + O(1)空间） #

更推荐用迭代法一次遍历完成反转，逻辑清晰且性能最优：

void rev(node* &head)
{
    node* prev = nullptr;
    node* curr = head;
    node* next = nullptr;

    while (curr != nullptr)
    {
        next = curr->next; // 保存下一个节点
        curr->next = prev; // 反转当前节点指针
        prev = curr;       // 前驱指针后移
        curr = next;       // 当前指针后移
    }
    head = prev; // 反转后的头节点是原链表的尾节点
}

补充提示 #

• 始终优先处理空链表、单节点链表这类边界情况，避免空指针访问。
• 动态分配的链表节点，除非确定不再使用，否则不要随意执行delete操作，避免内存泄漏或野指针问题。

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