Leetcode 206. 反转链表

题目描述

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

提示：

• 链表中节点的数目范围是 [0, 5000]
• -5000 <= Node.val <= 5000

 题目想要实现的效果 如图所示：之前链表的头节点是元素1， 反转之后头结点就是元素5 ，这里并没有添加或者删除节点，仅仅是改变next指针的方向。

可以使用双指针法，来解题：
完整代码：

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *cur = head;  // 当前节点指针，初始化为头节点
        ListNode *temp;        // 临时节点指针，用于保存当前节点的下一个节点
        ListNode *pre = NULL;  // 前一个节点指针，初始化为NULL

        // 遍历链表直到当前节点为空（因为最后一个节点也需要反转 就不能使用cur->next != NULL）
        while(cur) {
            temp = cur->next;   // 保存当前节点的下一个节点，因为链接即将被修改
            cur->next = pre;    // 将当前节点的next指针指向前一个节点，实现反转
            pre = cur;          // 移动前一个节点指针到当前节点
            cur = temp;         // 移动当前节点指针到下一个节点
        }
        // 当循环结束时，cur指向NULL，pre指向新的头节点（原链表的最后一个节点）
        return pre;
    }
};

例子：

有以下链表

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

想要将它反转。以下是各步骤中链表的状态变化：

• 初始状态:

  • cur 指向 1, pre 指向 NULL
  • 链表：1 -> 2 -> 3 -> 4 -> NULL

• 第一次迭代:

  • temp 保存 2 (即 cur->next)
  • 断开 1 的 next 指针并指向 pre (NULL), 然后更新 pre 到 1, cur 到 2
  • 链表现在看起来是：1 -> NULL 和独立的 2 -> 3 -> 4 -> NULL

• 第二次迭代:

  • temp 保存 3
  • 断开 2 的 next 指针并指向 pre (1), 然后更新 pre 到 2, cur 到 3
  • 链表现在看起来是：2 -> 1 -> NULL 和独立的 3 -> 4 -> NULL

• 第三次迭代:

  • temp 保存 4
  • 断开 3 的 next 指针并指向 pre (2), 然后更新 pre 到 3, cur 到 4
  • 链表现在看起来是：3 -> 2 -> 1 -> NULL 和独立的 4 -> NULL

• 第四次迭代:

  • temp 保存 NULL
  • 断开 4 的 next 指针并指向 pre (3), 然后更新 pre 到 4, cur 到 NULL
  • 链表现在看起来是：4 -> 3 -> 2 -> 1 -> NULL

• 结束:

  • cur 现在是 NULL, pre 是新的头节点，指向 4

最终反转后的链表是：

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

参考文章：代码随想录 (programmercarl.com)