LeetCode算法题（反转链表）Day17！！！C/C++

我是一只鱼0223

于 2025-05-05 15:40:17 发布

阅读量531

点赞数 13

文章标签：算法 leetcode 链表 c++ 数据结构

本文链接：https://blog.csdn.net/m0_75144071/article/details/147716626

版权

https://leetcode.cn/problems/reverse-linked-list/description/

一、题目分析

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。今天这道题目非常的言简意赅，就是给定一个链表将其反转后返回反转后的头节点。

二、示例分析

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

三、解题思路&代码实现

方法一：双指针法

我们可以定义一个前驱节点 pre 和一个当前节点 cur，初始时 pre = nullptr，cur 指向头节点。每次遍历时，我们暂存 cur 的下一个节点，然后将 cur->next 指向 pre，完成当前节点的反转。接着，pre 和 cur 分别向后移动，直到 cur 为 nullptr。此时 pre 指向反转后的新头节点，整个链表完成逆序。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        // 如果链表为空，直接返回nullptr
        if (head == nullptr)
            return nullptr;
        
        // pre指针用于记录当前节点的前一个节点，初始为nullptr
        ListNode* pre = nullptr;
        // cur指针用于遍历链表，初始指向头节点
        ListNode* cur = head;
        
        // 遍历链表，直到cur为nullptr（即链表末尾）
        while (cur) {
            // 临时保存当前节点的下一个节点，防止断链后丢失
            ListNode* t = cur->next;
            // 将当前节点的next指针指向前一个节点，实现反转
            cur->next = pre;
            // 移动pre指针到当前节点，为下一次迭代做准备
            pre = cur;
            // 移动cur指针到之前保存的下一个节点，继续遍历
            cur = t;
        }
        
        // 循环结束后，pre指向原链表的最后一个节点，即反转后的新头节点
        return pre;
    }
};

图文说明：

方法二：递归法

递归法和双指针法大致思想一致，具体实现代码稍稍有些差异，需要着重搞清楚每次递归时需要传的参数分别是什么。

class Solution {
public:
    // 递归反转链表的辅助函数
    // pre: 已经反转部分的头节点（初始为nullptr）
    // cur: 当前待反转的节点（初始为原链表头节点）
    ListNode* reverse(ListNode* pre, ListNode* cur) {
        // 递归终止条件：当前节点为空，说明已处理完所有节点
        // 此时pre就是反转后的新头节点
        if (cur == nullptr)
            return pre;
            
        // 保存当前节点的下一个节点，防止断链
        ListNode* t = cur->next;
        // 反转当前节点的指向
        cur->next = pre;
        
        // 递归处理下一个节点：
        // 新的pre变为当前节点（已反转部分的头节点）
        // 新的cur变为之前保存的下一个节点
        return reverse(cur, t);
    }
    
    // 主函数：反转整个链表
    ListNode* reverseList(ListNode* head) { 
        // 调用辅助函数
        // 这里等同于
        // ListNode* pre = nullptr;
        // ListNode* cur = head;
        return reverse(nullptr, head); 
    }
};

关键点说明：

递归思想：将链表分为“已反转部分“与”未反转部分“，每次处理一个节点。
终止条件：当cur为空时，说明所有节点已经反转完毕。
指针操作：每次递归调用前保存cur->next节点，防止找不到后继节点。将当前节点指向前驱节点。
参数传递：pre始终指向已反转部分的头节点，cur始终指向待处理的下一个节点

时间复杂度上与方法一相同，但空间复杂度为O(n)。个人感觉递归其实还是挺难理解的，但是当你搞清楚递归之后，在代码量上，会比普通写法要简介很多。

方法三：头插法（不提供代码，请同学自行实现）

这里主要讲述一下思想，感兴趣的小伙伴可以自己动手试一试。

核心思想：遍历原链表，逐一拿下每一个节点，插入到一个新链表的头部，最后新链表就是逆序后的链表。

关键步骤：

初始化一个虚拟头节点（dummy），作为新链表的辅助节点。
遍历原链表，每次操作：
- 保存当前节点的下一个节点（next = cur->next）。
- 将当前节点插入到新链表头部（cur->next = dummy->next）。
- 更新新链表的头（dummy->next = cur）。
- 移动当前节点到原链表的下一个节点（cur = next）。
返回 dummy->next，即逆序后的新链表头节点。

在上述两种方法如果大家掌握了的话，这种方法实现起来应该是没有问题的。虽然不推荐，但是相比方法一、二也是有好处，比如直观更容易理解，无需递归不需要考虑栈溢出。但这种方法主要还是锻炼大家的算法思维。

四、题目总结

双指针法：定义前驱指针 pre 初始为 nullptr，当前指针 cur 指向头节点。遍历链表，每次暂存 cur 的下一个节点 t，然后将 cur->next 指向 pre 实现当前节点反转，再移动 pre 和 cur 指针，直至 cur 为 nullptr，此时 pre 为反转后新头节点。时间复杂度 O (n)，空间复杂度 O (1) 。
递归法：将链表分为 “已反转部分” 和 “未反转部分”，通过递归处理节点。辅助函数 reverse 接收已反转部分头节点 pre（初始 nullptr）和当前待反转节点 cur（初始为头节点），保存 cur->next 防止断链，将 cur->next 指向 pre，再递归调用 reverse(cur, t) 处理下一个节点，终止条件为 cur 为空，此时 pre 是新头节点。时间复杂度 O (n) ，空间复杂度 O (n) 。
头插法：遍历原链表，把每个节点逐一插入新链表头部，新链表即为反转后的链表。思想直观，利于锻炼算法思维，无需递归避免栈溢出问题。