单链表的反转_leetcode

题目：

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

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
 #include<iostream>
 using namespace std;
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        
    }
};

先来详细介绍上述给出单链表基本节点的结构体，struct ListNode 。

在 C++ 中，结构体与类 (class) 类似，只是默认成员访问权限为 public。

1.struct ListNode有两个成员：

int val;//一个整型变量

ListNode *next；//一个指针，指向下一个节点。

正是将这一个个的基本节点用指针进行链接，才使链表的存在成为可能。

2..struct ListNode还有一个构造函数：

ListNode(int x) : val(x), next(nullptr) {}

   这个构造函数的作用是：

• 初始化 val 为 x（传入的参数）。

• 初始化 next 为 nullptr，表示该节点默认是 独立的，未连接到其他节点。

ListNode* node = new ListNode(5); 
cout << node->val;  // 输出 5
cout << node->next; // 输出 nullptr (0x0)

分析：

反转单链表的问题可以通过 迭代法 或 递归法 来解决。

假设我们有一个单链表：

head -> 1 -> 2 -> 3 -> 4 -> nullptr

我们要将其反转，使其变成：

nullptr <- 1 <- 2 <- 3 <- 4

1.迭代法

我们使用 三个指针 来完成反转：

1. prev（前一个节点，初始值为空）

2. curr（当前节点，从 head 开始）

3. next（临时保存 curr 的下一个节点，防止链表断裂）

思路是：

• 依次遍历链表，每次调整指针方向。

• 关键一步是让 curr->next 指向 prev，然后 prev,cur,next往前移动。这样就逐步翻转链表。

核心代码：

#include <iostream>
using namespace std;
​
// 定义单链表节点结构
struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {} // 构造函数
};
​
// 反转单链表（迭代法）
ListNode* reverseList(ListNode* head) {
    ListNode* pre = nullptr;
    ListNode* cur = head;
    ListNode* next = nullptr;
​
    while (cur) {
        next = cur->next; // 先保存下一个节点，防止链表断裂
        cur->next = pre;  // 反转当前节点的指向
        pre = cur;        // pre前进
        cur = next;       // cur前进
    }
    
    return pre;
}

现在我们就以上代码思考几个问题：

1）在指针初始化时，为什么要让next一开始为空，而不设为next = cur->next。

2）c++的空指针是怎么表示的？

3) while()循环括号中应该设什么条件？

4）怎么看诸如next = cur->next;这些赋值语句？

==》

1）因为： 当 head == nullptr（链表为空）时，head->next 会 访问空指针，导致程序崩溃。

换言之， 我们初始化 next 为 nullptr 是为了确保在 首次进入循环之前，没有访问 cur->next。这样做的目的是避免 未定义行为，特别是在链表为空或链表的尾部情况下。

2） 在 C++ 中，空指针通过 nullptr 来表示。

nullptr 是 C++11 引入的，作为 标准的空指针类型。它代替了旧版本 C++ 中的 NULL 或 0。

在 C++98 中，我们经常看到 NULL 来表示空指针， 然而，nullptr 是类型安全的，能够避免一些潜在的错误。

3）while(condition)： condition 是一个 布尔表达式，它在每次循环开始时会被评估。如果条件为 true（即条件满足），则 进入循环体，执行循环中的代码。

我们这里的判断是若cur是一个有效节点，则让它进入循环体，即cur!=nullptr;

4）next = cur->next;这样的赋值语句可以看成next(即前面的部分)要成为xxx。

例如这条代码的作用就是next变成了 cur->next;

测试

​
// 打印链表
void printList(ListNode* head) {
    while (head) {
        cout << head->val << " -> ";
        head = head->next;
    }
    cout << "nullptr" << endl;
}
​
// 测试代码
int main() {
    // 创建链表 1 -> 2 -> 3 -> 4 -> nullptr
    ListNode* head = new ListNode(1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(3);
    head->next->next->next = new ListNode(4);
​
    cout << "原链表: ";
    printList(head);
​
    // 反转链表
    head = reverseList(head);
​
    cout << "反转后的链表: ";
    printList(head);
​
    return 0;
}

2.递归法

递归思路我们可以用一个递归调用栈来思考。

在某一特定的层中，传进来的参数是ListNode* head.

由于需要先一层层调用上一层函数，故先使用递归调用让调用一层层深入。而后终止条件是：

!head || !head->next 。例如最后一个有效节点是4，因为4的下一个节点为空，故返回4。

接着进入本层的核心处理：(以3为例）

获取上一层返回的节点newhead（即4）

让head的下一个节点反指head。（即让4->3）

断开head->next,避免形成环。（即让3->nullptr）

最后返回newhead。（到这一步的链表已是4->3）

总结：

关于递归过程，我们基本上可以遵照下面的思路来进行。

• 递归进入：逐层深入，直到链表的最后一个节点。
• 递归终止：当到达链表的最后一个节点时，返回该节点。
• 回溯处理：本层递归要处理的事情，然后返回。

递归的执行过程

递归的执行过程 以链表 1 -> 2 -> 3 -> 4 -> null 为例来演示递归是如何工作的。

第1步：从 1 开始调用 reverseListRecursive(1)，进入递归：head = 1，继续递归，调用 reverseListRecursive(2)。

第2步：进入到 2： head = 2，继续递归，调用 reverseListRecursive(3)。

第3步：进入到 3： head = 3，继续递归，调用 reverseListRecursive(4)。

第4步：进入到 4： head = 4，到达链表的最后一个节点，head->next == null，触发递归终止条件，返回 head（即 4）作为反转后链表的新的头节点。

第5步：

        回溯到 3： 现在回溯到上一级，

                head = 3，此时的 newHead = 4（即从 reverseListRecursive(4) 返回）。

                执行 head->next->next = head;：3->next（即 4）的 next 指向 3，变成 4 -> 3。

                执行 head->next = nullptr;：将 3->next 置为 nullptr，这样链表变成了 4 -> 3 -> null。

                 然后返回 newHead = 4 给上一层（也就是 reverseListRecursive(2)）。

第6步：

        回溯到 2： 继续回溯到 2，head = 2，此时的 newHead = 4。

                执行 head->next->next = head;：2->next（即 3）的 next 指向 2，变成 3 -> 2。

                 执行 head->next = nullptr;：将 2->next 置为 nullptr，变成了 4 -> 3 -> 2 -> null。

                 然后返回 newHead = 4 给上一层（也就是 reverseListRecursive(1)）。

第7步：

        回溯到 1：

                 回到最初的递归层，head = 1，此时的 newHead = 4。

                执行 head->next->next = head;：1->next（即 2）的 next 指向 1，变成 2 -> 1。

                 执行 head->next = nullptr;：将 1->next 置为 nullptr，变成了 4 -> 3 -> 2 -> 1 -> null。                 最终，返回 newHead = 4，也就是链表反转后的新头节点。

递归代码

ListNode* reverseListRecursive(ListNode* head) {
    if (!head || !head->next) return head; // 终止条件
​
    ListNode* newHead = reverseListRecursive(head->next); // 递归反转子链表
    head->next->next = head; // 让 head 的下一个节点反指向 head
    head->next = nullptr; // 断开 head 的 next，避免形成环
​
    return newHead; // 返回新的头节点
}

根据以上代码我们提出几个问题：

为什么终止条件不能只有!head->next？

====》

正确的判断应该是：

如果 head == nullptr，递归会终止。

如果 head->next == nullptr，说明链表只剩下一个节点，递归也会终止，返回该节点。

即要考虑到链表空的时候。

结果