Leetcode刷题日记-链表（一）

归纳总结

做题技巧

• 一个指针快，一个指针慢，相隔距离是多少
• 两个指针的移动速度
• 递归

下面是一些总结题型

1. 链表的中间结点 (876)

题目可以看-原题地址
给定一个带有头结点 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

示例 1：

输入：[1,2,3,4,5]
输出：此列表中的结点 3 (序列化形式：[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意，我们返回了一个 ListNode 类型的对象 ans，这样：
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL

思路：

• 设置两个指针 i 和 j，j 的移动速度是 i 的2倍，这样当 j 走到链表末尾的时候 i 走了总长度的一半，自然是中间节点了
  

class Solution:
    def middleNode(self, head: ListNode) -> ListNode:
        i = head
        j = head
        while j and j.next:
            i = i.next
            j = j.next.next
        return i

2. 剑指Offer-22 链表中倒数第k个节点

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。

示例：

给定一个链表: 1->2->3->4->5, 和 k = 2.

返回链表 4->5.
思路：
设置两个指针a,b，b相隔a有k个节点，同速前行，直到b指针出界，那么a指针则为链表中倒数第K个节点。

class Solution:
    def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
        i = head
        j = head
        for x in range(k):
            j = j.next
        while j:
            i = i.next
            j = j.next
        return i

3. 剑指Offer-52 两个链表的第一个公共节点

题目可以看原题地址
编写一个程序，找到两个单链表相交的起始节点。
如下面的两个链表：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
常规思路
（1）先固定一个节点如headA
（2）headB遍历一遍，虽然A得4和B得4值相同但是不是一个引用。B遍历完成之后，A走下一个，B在遍历一圈。直到A和B得节点重合
（3）这是一个双循环，时间复杂度为O(n^2)
思路：
（1）根据链表得特性我们可以知道，如果两个链表有公共节点是不可能出现以下情况得，因为每个节点，只有一个next。

（2）要求时间复杂度为 O(N)，空间复杂度为 O(1)。如果不存在交点则返回 null。

（3）设 A 的长度为 a + c，B 的长度为 b + c，其中 c 为尾部公共部分长度，可知 a + c + b = b + c + a。

（4）当访问 A 链表的指针访问到链表尾部时，令它从链表 B 的头部开始访问链表 B；同样地，当访问 B 链表的指针访问到链表尾部时，令它从链表 A 的头部开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。

（5）如果不存在交点，那么 a + b = b + a，以下实现代码中 node1 和 node2 会同时为 null，从而退出循环。
（6）单次循环，复杂度为O(n)

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        node1, node2 = headA, headB
        
        while node1 != node2:
            node1 = node1.next if node1 else headB
            node2 = node2.next if node2 else headA

        return node1

4. 环形链表 (141)

题目可以看原题地址
给定一个链表，判断链表中是否有环。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例2：

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。
思路：

分析题目：题目要求我们判断他是否是环形链表。而不是说让我们根据pos连接环形链表。
首先我们设置一个快指针和一个慢指针slow，慢指针fast每次走一个，快指针每次走两个，当链表不是环形，那么fast最快走到链表尾部或者出界，那么代表不是环形链表。
然后，假如是环形链表，假如slow差一步，那么下次迭代相遇，若差两步以上，下下次跌倒也会相遇。
设置头节点为slow，头节点的下一个节点是fast，设置不一样的原因是，下面循环终止的条件是当fast = slow

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        slow = head
        find = False
        if slow == None or slow.next == None:
            return find
        fast = head.next
       
        while slow != fast:
            if (fast == None or fast.next ==None):
                return find
            slow = slow.next
            fast = fast.next.next
        find = True
        return find

5. 删除链表中的节点 (273)

题目可以看原题地址
请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。

示例 1:

输入: head = [4,5,1,9], node = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

说明:
链表至少包含两个节点。
链表中所有节点的值都是唯一的。
给定的节点为非末尾节点并且一定是链表中的一个有效节点。
不要从你的函数中返回任何结果。
思路：

首先一定要审清题，由于我们只知道要删除的节点，和该节点之后的节点，所以不能够使用node之前的节点next指向node之后的节点。
然后分析，我们可以让node这个节点的值等于后一个节点的值，然后node.next = node.next.next，即可将后一个节点删除，完成题目要求。

class Solution:
    def deleteNode(self, node):
        """
        :type node: ListNode
        :rtype: void Do not return anything, modify node in-place instead.
        """
        node.val = node.next.val
        node.next = node.next.next

6. 删除链表的倒数第N个节点 (19)

题目可以看原题地址
给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

示例：

给定一个链表: 1->2->3->4->5, 和 n = 2.

当删除了倒数第二个节点后，链表变为 1->2->3->5.

思路：
（1）首先我们遍历一遍链表，得到链表的总长度count
（2）然后将cur和pre遍历到相应位置count-n，此时cur所指向的位置就是我们要删除的倒数第n个节点。
（3）设置dummy节点，防止删除第一个节点时报错

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        dummy = ListNode(0)
        dummy.next = head
        pre = dummy
        cur = head
        
        count = 0 
        while cur :
            cur = cur.next
            count += 1

        cur = head
        for i in range(count - n):
            pre = cur 
            cur = cur.next
        pre.next = cur.next
        return dummy.next

思路：
（1）可以利用两个指针之间得间隔，当cur指向None即出界时，利用距离为n的节点之前的pre节点来完成这道题目，pre.next = pre. next.next
（2）注意特殊情况，删除的为第一个节点时，这时我们要设置一个dummy节点

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        dummy = ListNode(0)
        dummy.next = head
        cur = head
        pre = dummy
        
        for i in range(n):
            cur = cur.next
        while cur :
            cur = cur.next
            pre = pre.next
        pre.next = pre.next.next
        return dummy.next