【刷题笔记5】LeetCode 206. 反转链表 (链表必刷题）

系列索引 ： 【刷题笔记0】系列目录索引（持续更新 & 推荐收藏）

本题题目： LeetCode 206. 反转链表

分类： 链表， 遍历， 思维

难度： 简单

老规矩，先上AC图：

---

题目：

206. 反转链表（点击直达原网站）

示例 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
 

进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

---

题解：

注意事项：

• 在写链表题涉及到开合键的操作，一定要在纸上把过程先画出来，再写程序！
• 当用到 node -> next时要有意识的先判断node -> next是否存在，不要越界；不然就runtime error！
• 注意最后的终止条件！

解法一： 遍历迭代

时间复杂度： O(N)；  空间复杂度： O(1).

这种方法也是最经典的解法，就是从头开始，在遍历链表时，将当前节点的next 指针改为指向前一个节点,比如 2 ->3， 改为2 -> 1；

由于前一个节点没法直接寻找，因此需要定义一个指针，在遍历过程中就事先存储其前一个节点。在更改 -> next 引用之前，还需要定义一个指针存储后一个节点， 防止后面结点丢失。

最后返回新的头引用（最后一个结点）

过程如图：（图源 【反转链表】：双指针，递归，妖魔化的双指针）

代码如下：

/**
 * 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) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* node = head;
        while(node != nullptr){
            ListNode* bar = node -> next;
            node -> next = pre;
            pre = node;
            node = bar;
        }
        return pre;
    }
};

 但是通过上面的代码分析，while中定义的bar是否多余？是否可以更近一步？

通过图可以知道，head结点在第一次更改后 -> next 就指向null了，其实这个是可以利用起来的，用来指向node后的结点，在最后再更新成null，省下一个结点的定义。

过程如图：

 代码如下：

/**
 * 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) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr) return head;
        ListNode* pre = head;
        ListNode* node = head -> next;
        while(node != nullptr){
            head -> next = node -> next;
            node -> next = pre;
            pre = node;
            node = head -> next;
        }
        return pre;
    }
};

 解法二： 递归

时间复杂度O(N)，空间复杂度O(N)主要取决于递归调用的栈空间，最多为 N 层。

递归的方法不太好理解，但是这道题用递归是完美的利用了递归的特性，非常妙。

• 使用递归函数，一直递归到链表的最后一个结点，该结点就是反转后的头结点，记作 ret .
• 此后，每次函数在返回的过程中，让当前结点的下一个结点的 next 指针指向当前节点。
• 同时让当前结点的 next 指针指向 NULL ，从而实现从链表尾部开始的局部反转
• 当递归函数全部出栈后，链表反转完成。

代码如下： 

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head == NULL || head->next == NULL) {
            return head;
        }
        ListNode* ret = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;
        return ret;
    }
};

解法三： 辅助存储（取巧做法）

时间复杂度O(N)，空间复杂度O(N)

这种做法就是偏向于一种取巧做法，和链表的特性无关，这里不再赘述。

主要过程：

• 先定义一个容器用来存储链表数值。（栈或者数组）；
• 之后先遍历一遍，获取数值，存进去。
• 之后再遍历一遍，将之前获取的数值重新赋值到原链表。（栈就顺序出栈，数组就倒序输出）

 上一篇： 从B站 (哔哩哔哩) 泄露的源码里发现了B站视频推荐的秘密

下一篇： 400+条实用C/C++框架、库、工具整理 ，你能想到的都在这里了

如果有什么要补充的，欢迎下方👇评论区留言~

1份赞许 = 100分的认可，如果感觉还不错，点个赞👍 支持一下吧 ~

不定期分享 有趣、有料、有营养内容，欢迎 订阅关注 🤝 我的博客 ，期待在这与你相遇 ~