24. 反转链表

剑指offer 24 反转链表 LeetCode206

206. 反转链表

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

限制：

0 <= 节点个数 <= 5000

注意：本题与主站 206 题相同：https://leetcode-cn.com/problems/reverse-linked-list/

解题思路：

写该题时，应该先问面试官能不能修改原链表，如果不可以，那我们看到反转，第一反应应该是想到栈的先进后出特性，即用一个栈来辅助反转，建立一个新的链表。如果可以修改原链表，那么面试官的初心应该就是让我们原地反转给定的链表。

解法一：使用栈

Java代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null || head.next == null) return head;
        Stack<ListNode> stack = new Stack<>();
        ListNode cur = head;
        //入栈
        while(cur != null){
            stack.push(cur);
            cur = cur.next;
        }
        //建立虚拟头节点，构建新的链表
        ListNode dummy = new ListNode(0);
        cur = dummy;
        while(!stack.isEmpty()){
            cur.next = stack.pop();
            cur = cur.next;
        }
        //注意这一句不能少，否则最后两个节点会形成环，
        //如题中反转后2的下一个节点是1，而原链表1的下一个节点是2
        //如果没有下面这行代码，2的下一个节点是1，1的下一节点是2，而不是null，形成环了
        cur.next = null;
        return dummy.next;
    }
}

解法二:原地反转链表

头插法。共三个关键结点，如图：

Java代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        //思路：不断让后面的结点连到dummy的后面，结点遍历完毕，也就反转完毕了
        if(head == null) return head;
        //由于用的是头插法，即后面的节点需要插在当前头节点之前，所以声明一个虚拟头节点
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        //表示本次要插入到dummy后的结点，即插入到原始链表的头节点位置
        ListNode cur = dummy.next.next;
        //tail指向一直不变，改变的是tail.next,用于将已经反转的部分链表和剩余还需要反转的链表相连
        ListNode tail = head;

        while(cur != null){
            //记住下一个需要头插的节点，避免等下cur.next改变指向，就找不到原来的cur.next了
            ListNode nxt = cur.next;
            cur.next = dummy.next;
            dummy.next = cur;
            tail.next = nxt;//将已经反转的部分链表和剩余还需要反转的链表相连
            cur = nxt;//下一个要头插的节点
        }
        return dummy.next;
    }
}

Go代码

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func reverseList(head *ListNode) *ListNode {
    // 经典头插法，cur一直指着需要头插的节点
    if head == nil || head.Next == nil {
        return head
    }
    dummy := &ListNode{}
    dummy.Next = head
    cur := dummy.Next.Next // cur从一开始就指着需要头插的节点，表示本次要插入到dummy后的结点
    tail := dummy.Next  //tail指向一直不变，改变的是tail.next,用于将已经反转的部分链表和剩余还需要反转的链表相连

    for cur != nil {
        tail.Next = cur.Next //将已经反转的部分链表和剩余还需要反转的链表相连
        cur.Next = dummy.Next
        dummy.Next = cur
        cur = tail.Next //下一个要头插的节点
    }
    return dummy.Next
} 

解法三：递归

首先我们先考虑 reverseList 函数能做什么，它可以翻转一个链表，并返回新链表的头节点，也就是原链表的尾节点。
所以我们可以先递归处理 reverseList(head.next)，这样我们可以将以head.next为头节点的链表翻转，并得到原链表的尾节点tail,它也是新链表的头节点，此时因为进行了反转，head.next是新链表的尾节点，我们令它的next指针指向head，并将head.next指向空即可将整个链表翻转，且新链表的头节点是tail。

空间复杂度分析： 总共递归 n 层，系统栈的空间复杂度是 $O(n)$，所以总共需要额外 $O(n)$ 的空间。
时间复杂度分析： 链表中每个节点只被遍历一次，所以时间复杂度是 $O(n)$。

Java代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null || head.next == null) return head;
        ListNode tail = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return tail;
    }
}