剑指 Offer 24. 反转链表

持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第17天，点击查看活动详情

反转链表太常见了

Leetcode : leetcode-cn.com/problems/fa…

GitHub : github.com/nateshao/le…

剑指 Offer 24. 反转链表

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

示例:

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

限制：0 <= 节点个数 <= 5000

解题思路：

如下图所示，题目要求将链表反转。有迭代（双指针）、递归两种实现方法。

Go

func reverseList(head *ListNode) *ListNode {
    var prev *ListNode
    curr:=head
    for curr!=nil{
        next :=curr.Next   //保存当前节点的下一个节点
        curr.Next=prev     //当前节点的下一个节点更新为前一个节点
       prev=curr            //前节点更新为现节点
        curr=next            //现节点更新为下一个节点
    }
    return prev
}

方法一：迭代（双指针）

考虑遍历链表，并在访问各节点时修改 next 引用指向，算法流程见注释。

复杂度分析：

• 时间复杂度 O(N)： 遍历链表使用线性大小时间。

• 空间复杂度 O(1)： 变量 pre 和 cur 使用常数大小额外空间。

package com.nateshao.sword_offer.topic_18_reverseList;

/**
 * @date Created by 邵桐杰 on 2021/11/22 19:41
 * @微信公众号 千羽的编程时光
 * @个人网站 www.nateshao.cn
 * @博客 https://nateshao.gitee.io
 * @GitHub https://github.com/nateshao
 * @Gitee https://gitee.com/nateshao
 * Description: 反转链表
 * 思路：定义两个指针，反向输出
 * https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof
 */
public class Solution {

    /**
     * 解法一：迭代：两个指针，反向输出，时间复杂度：O(n)，空间复杂度：O(1)
     *
     * @param head
     * @return
     */
    public ListNode reverseList(ListNode head) 
        ListNode pre = null;
        ListNode cur = head;
        while (cur != null) {
            ListNode tmp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
	/**
     * 解法一：迭代2：两个指针
     * 精选解答
     *
     * @param head
     * @return
     */
    public ListNode reverseList1(ListNode head) {
        ListNode cur = head, pre = null;
        while (cur != null) {
            ListNode tmp = cur.next; // 暂存后继节点 cur.next
            cur.next = pre;          // 修改 next 引用指向
            pre = cur;               // pre 暂存 cur
            cur = tmp;               // cur 访问下一节点
        }
        return pre;
    }
    public class ListNode {
        int val;
        ListNode next;
        ListNode(int x) {
            val = x;
        }
    }
}

方法二：递归

Go递归

func reverseList(head *ListNode) * ListNode{
    if head==nil  || head.Next==nil{
        return head
    }
    newHead:=reverseList(head.Next)
    head.Next.Next=head
    head.Next=nil
    return newHead
}

考虑使用递归法遍历链表，当越过尾节点后终止递归，在回溯时修改各节点的 next 引用指向。

recur(cur, pre) 递归函数：

1. 终止条件：当 cur 为空，则返回尾节点 pre （即反转链表的头节点）；
2. 递归后继节点，记录返回值（即反转链表的头节点）为 res ；
3. 修改当前节点 cur 引用指向前驱节点 pre ；
4. 返回反转链表的头节点 res ；

reverseList(head) 函数：

​ 调用并返回 recur(head, null) 。传入 null 是因为反转链表后， head 节点指向 null ；

复杂度分析：

• 时间复杂度 O(N)) ： 遍历链表使用线性大小时间。

• 空间复杂度 O(N)： 遍历链表的递归深度达到 N ，系统使用 O(N)大小额外空间。

package com.nateshao.sword_offer.topic_18_reverseList;

/**
 * @date Created by 邵桐杰 on 2021/11/22 19:41
 * @微信公众号 千羽的编程时光
 * @个人网站 www.nateshao.cn
 * @博客 https://nateshao.gitee.io
 * @GitHub https://github.com/nateshao
 * @Gitee https://gitee.com/nateshao
 * Description: 反转链表
 * 思路：定义两个指针，反向输出
 * https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof
 * https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof/solution/jian-zhi-offer-24-fan-zhuan-lian-biao-die-dai-di-2/
 */
public class Solution {

    /**
     * 递归：时间复杂度：O(n)，空间复杂度：O(n)
     *
     * @param head
     * @return
     */
    public static ListNode reverseList3(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode newHead = reverseList3(head.next);
        head.next.next = head;
        head.next = null;
        return newHead;
    }

    public ListNode reverseList4(ListNode head) {
        ListNode cur = head, pre = null;
        while (cur != null) {
            ListNode tmp = cur.next; // 暂存后继节点 cur.next
            cur.next = pre;          // 修改 next 引用指向
            pre = cur;               // pre 暂存 cur
            cur = tmp;               // cur 访问下一节点
        }
        return pre;
    }


    public class ListNode {
        int val;
        ListNode next;

        ListNode(int x) {
            val = x;
        }
    }

}