Leetcode（206）——反转链表

原创已于 2022-05-20 09:15:57 修改 · 208 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#链表 #leetcode #算法

于 2022-05-19 16:33:42 首次发布

Leetcode 专栏收录该内容

77 篇文章

订阅专栏

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

方法一：递归之尾插法

思路

递归版本稍微复杂一些，其关键在于反向工作。假设链表的其余部分已经被反转，现在应该如何反转它前面的部分？

假设链表为：
$n1→…→nk−1→nk→nk+1→…→nm→∅n_1\rightarrow \ldots \rightarrow n_{k-1} \rightarrow n_k \rightarrow n_{k+1} \rightarrow \ldots \rightarrow n_m \rightarrow \varnothing$

若从节点 $n_{k+1}$ 到 $n_m$ 已经被反转，而我们正处于 $n_k$ 。
$n1→…→nk−1→nk→nk+1←…←nmn_1\rightarrow \ldots \rightarrow n_{k-1} \rightarrow n_k \rightarrow n_{k+1} \leftarrow \ldots \leftarrow n_m$

我们希望 $n_{k+1}$ 的下一个节点指向 $n_k$ 。所以， $nk.next.next=nkn_k.\textit{next}.\textit{next} = n_k$ 。
需要注意的是 $n_1$ 的下一个节点必须指向 $∅\varnothing$ 。如果忽略了这一点，链表中可能会产生环。

算法解析：

假设初始链表为 1->2->3->4->5

第一轮出栈，head为5，head->next为空，返回5
第二轮出栈，head为4，head->next为5，执行 head->next->next=head 也就是5.next=4，
把当前节点的子节点的子节点指向当前节点
此时链表为1->2->3->4<->5，由于4与5互相指向，所以此处要断开4.next=null
此时链表为1->2->3->4<-5
返回节点5
第三轮出栈，head为3，head->next为4，执行 head->next->next=head 也就是4.next=3，
此时链表为1->2->3<->4<-5，由于3与4互相指向，所以此处要断开3.next=null
此时链表为1->2->3<-4<-5
返回节点5
第四轮出栈，head为2，head->next为3，执行 head->next->next=head 也就是3.next=2，
此时链表为1->2<->3<-4<-5，由于2与3互相指向，所以此处要断开2.next=null
此时链表为1->2<-3<-4<-5
返回节点5
第五轮出栈，head为1，head->next为2，执行 head->next->next=head 也就是2.next=1，
此时链表为1<->2<-3<-4<-5，由于1与2互相指向，所以此处要断开1.next=null
此时链表为1<-2<-3<-4<-5
返回节点5
出栈完成，最终头节点5->4->3->2->1

代码实现

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        // 直到当前结点的下一个结点为空时返回当前结点
        if (!head || !head->next)
            return head;
        ListNode* newHead = reverseList(head->next);// 递归传入下一个节点，目的是为了到达最后一个节点
        head->next->next = head;
        head->next = nullptr;
        return newHead;
    }
};

复杂度分析

时间复杂度： $O (N)$ ，其中 $N$ 是链表的长度。需要对链表的每个节点进行反转操作。
空间复杂度： $O (N)$ ，其中 $N$ 是链表的长度。空间复杂度主要取决于递归调用的栈空间，最多为 $N$ 层。

方法二：迭代之头插法

思路

在方法二中，我们采用头插法+头结点+迭代来实现链表的逆序。

代码实现

/**
 * 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 || head->next == nullptr) return head;
        ListNode* newone = new ListNode(0, nullptr);   // 头结点
        ListNode* tmp = nullptr;
        // 头插法
        while(head != nullptr){
            tmp = head;
            head = head->next;
            tmp->next = newone->next;
            newone->next = tmp;
        }
        tmp = newone;
        newone = newone->next;  // 去除头结点
        delete tmp;// 释放资源
        return newone;
    }
};