Leetcode的AC指南 —— 链表:206. 反转链表

摘要:
Leetcode的AC指南 —— 链表:206. 反转链表。题目介绍:给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。

文章目录

  • 一、题目
  • 二、解析
    • 1、双指针法
    • 2、递归法
  • 三、总结

一、题目


题目介绍:给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。

力扣题目链接

示例 1:
Leetcode的AC指南 —— 链表:206. 反转链表_第1张图片

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

示例 2:
Leetcode的AC指南 —— 链表:206. 反转链表_第2张图片

输入:head = [1,2]
输出:[2,1]

示例3:

输入:head = []
输出:[]

提示:
链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

进阶:

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

二、解析


如果再定义一个新的链表,实现链表元素的反转,其实这是对内存空间的浪费。

其实只需要改变链表的next指针的指向,直接将链表反转 ,而不用重新定义一个新的链表,如图所示:
Leetcode的AC指南 —— 链表:206. 反转链表_第3张图片

1、双指针法

我们拿有示例中的链表来举例,如动画所示:(纠正:动画应该是先移动pre,在移动cur)


首先定义一个cur指针,指向头结点,再定义一个pre指针,初始化为null。

然后就要开始反转了,首先要把 cur->next 节点用tmp指针保存一下,也就是保存一下这个节点。

为什么要保存一下这个节点呢,因为接下来要改变 cur->next 的指向了,将cur->next 指向pre ,此时已经反转了第一个节点了。

接下来,就是循环走如下代码逻辑了,继续移动pre和cur指针。

最后,cur 指针已经指向了null,循环结束,链表也反转完毕了。 此时我们return pre指针就可以了,pre指针就指向了新的头结点。

	public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode cur = head;
        ListNode temp = null;
        while (cur != null) {
            temp = cur.next;// 保存下一个节点
            cur.next = prev;
            prev = cur;
            cur = temp;
        }
        return prev;
    }
  • 时间复杂度: O(n)
  • 空间复杂度: O(1)

2、递归法

a. 从前向后翻转指针发的递归
递归法相对抽象一些,但是其实和双指针法是一样的逻辑,同样是当cur为空的时候循环结束,不断将cur指向pre的过程。

关键是初始化的地方,可能有的同学会不理解, 可以看到双指针法中初始化 cur = head,pre = NULL,在递归法中可以从如下代码看出初始化的逻辑也是一样的,只不过写法变了。

具体可以看代码(已经详细注释),双指针法写出来之后,理解如下递归写法就不难了,代码逻辑都是一样的。

	// 每次从链表中摘下一个节点,作为pre的头节点。
	public ListNode reverseList(ListNode head) {
        return reverse(null, head);
    }

    private ListNode reverse(ListNode prev, ListNode cur) {
        if (cur == null) {
            return prev;
        }
        ListNode temp = null;
        temp = cur.next;// 先保存下一个节点
        cur.next = prev;// 反转
        // 更新prev、cur位置
        // prev = cur;
        // cur = temp;
        return reverse(cur, temp);
    }
  • 时间复杂度: O(n), 要递归处理链表的每个节点
  • 空间复杂度: O(n), 递归调用了 n 层栈空间

b.从后向前翻转指针的递归
我们可以发现,上面的递归写法和双指针法实质上都是从前往后翻转指针指向,其实还有另外一种与双指针法不同思路的递归写法:从后往前翻转指针指向。

具体代码如下(带详细注释):

	// 从后向前递归,是我自己写不出来的方法,好抽象
	ListNode reverseList(ListNode head) {
        // 边缘条件判断
        if(head == null) return null;
        if (head.next == null) return head;
        
        // 递归调用,翻转第二个节点开始往后的链表
        ListNode last = reverseList(head.next);
        // 翻转头节点与第二个节点的指向
        head.next.next = head;
        // 此时的 head 节点为尾节点,next 需要指向 NULL
        head.next = null;
        return last;
    } 

三、总结


我的题解:

//做完后反应过来是用了双指针
 public ListNode reverseList(ListNode head) { // 双指针
        if(head == null) return head;

        ListNode pre = head;
        ListNode cur = pre.next;
        while (cur != null){
            pre.next = cur.next;
            cur.next = head;
            head = cur;
            cur = pre.next;
        }
        return head;
    }

你可能感兴趣的:(leetcode的AC指南,leetcode,链表,算法)