反转链表方法

ListNode *reverse(ListNode *L)
    {
        ListNode *prev=NULL,*curr=L,*next=NULL;//前驱节点，当前节点，下一个节点
        while(curr!=NULL)
        {
            next=curr->next;//下一个节点
            curr->next=prev;//把当前节点的next域指向前驱节点
            prev=curr;//前驱节点向后移动到当前节点
            curr=next;//当前节点向后移动到下一个节点
        }
        return prev;//最后curr指向了null，prev变成了新的头结点
    }

初始状态

假设链表为 1 -> 2 -> 3 -> 4 -> 5 -> NULL，初始时：

• head 指向节点 1。

• prev 初始化为 NULL。

• curr 初始化为 head，即指向节点 1。

• next 初始化为 NULL。

链表状态：

复制

1 -> 2 -> 3 -> 4 -> 5 -> NULL

第一次循环

1. next = curr->next：

   • curr 指向节点 1，curr->next 是节点 2。

   • 将 next 指向节点 2。

2. curr->next = prev：

   • prev 是 NULL，将 curr->next 指向 NULL。

   • 现在节点 1 的 next 指针被修改为 NULL。

3. prev = curr：

   • 将 prev 指向当前节点 1。

4. curr = next：

   • 将 curr 指向节点 2。

链表状态：

复制

NULL <- 1    2 -> 3 -> 4 -> 5 -> NULL

第二次循环

1. next = curr->next：

   • curr 指向节点 2，curr->next 是节点 3。

   • 将 next 指向节点 3。

2. curr->next = prev：

   • prev 指向节点 1，将 curr->next 指向节点 1。

   • 现在节点 2 的 next 指针被修改为指向节点 1。

3. prev = curr：

   • 将 prev 指向当前节点 2。

4. curr = next：

   • 将 curr 指向节点 3。

链表状态：

复制

NULL <- 1 <- 2    3 -> 4 -> 5 -> NULL

第三次循环

1. next = curr->next：

   • curr 指向节点 3，curr->next 是节点 4。

   • 将 next 指向节点 4。

2. curr->next = prev：

   • prev 指向节点 2，将 curr->next 指向节点 2。

   • 现在节点 3 的 next 指针被修改为指向节点 2。

3. prev = curr：

   • 将 prev 指向当前节点 3。

4. curr = next：

   • 将 curr 指向节点 4。

链表状态：

复制

NULL <- 1 <- 2 <- 3    4 -> 5 -> NULL

第四次循环

1. next = curr->next：

   • curr 指向节点 4，curr->next 是节点 5。

   • 将 next 指向节点 5。

2. curr->next = prev：

   • prev 指向节点 3，将 curr->next 指向节点 3。

   • 现在节点 4 的 next 指针被修改为指向节点 3。

3. prev = curr：

   • 将 prev 指向当前节点 4。

4. curr = next：

   • 将 curr 指向节点 5。

链表状态：

复制

NULL <- 1 <- 2 <- 3 <- 4    5 -> NULL

第五次循环

1. next = curr->next：

   • curr 指向节点 5，curr->next 是 NULL。

   • 将 next 指向 NULL。

2. curr->next = prev：

   • prev 指向节点 4，将 curr->next 指向节点 4。

   • 现在节点 5 的 next 指针被修改为指向节点 4。

3. prev = curr：

   • 将 prev 指向当前节点 5。

4. curr = next：

   • 将 curr 指向 NULL。

链表状态：

复制

NULL <- 1 <- 2 <- 3 <- 4 <- 5

循环结束

• curr 变为 NULL，循环终止。

• prev 指向节点 5，即新的头节点。

最终链表

反转后的链表为：

复制

5 -> 4 -> 3 -> 2 -> 1 -> NULL

总结

• 核心思想：通过三个指针（prev、curr、next）逐个修改节点的 next 指针方向。

• 时间复杂度：O(n)O(n)，只需遍历链表一次。

• 空间复杂度：O(1)O(1)，只使用了常数级别的额外空间。

通过这种方式，链表被成功反转！