代码随想录算法训练营第四天 |24. 两两交换链表中的节点，19.删除链表的倒数第N个节点，面试题 02.07. 链表相交，142.环形链表II，总结

24. 两两交换链表中的节点

题目：

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：输入：head = [1,2,3,4]    输出：[2,1,4,3]
示例 2：输入：head = []               输出：[]
示例 3：输入：head = [1]             输出：[1]

思路：

        设置虚拟头节点，创建临时结点保存结点1和结点3，考虑到奇数、偶数、空链表的情况，确定遍历何时结束。

代码：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next


class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        dummy_head = ListNode(next=head)  #  创建虚拟头节点的方式，需要熟练掌握
        cur = dummy_head
        
        while cur.next != None and cur.next.next != None:
            temp = cur.next  # 临时节点，保存结点1
            temp1 = cur.next.next.next  # 保存结点３
            
            cur.next = cur.next.next  # 虚拟头节点指向结点2
            cur.next.next = temp  # 结点2指向结点1
            temp.next = temp1  # 结点1指向结点3

            cur = cur.next.next  # 结点后移，该处理下一对数字

        return dummy_head.next

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

题目：

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例1： 输入：head = [1,2,3,4,5], n = 2             输出：[1,2,3,5]

示例 2： 输入：head = [1], n = 1                        输出：[]

示例 3： 输入：head = [1,2], n = 1                     输出：[1]

思路：

利用快慢双指针的方法。画图！

 # 快指针比慢指针先走n+1步。这一步对我来说比较难且重要。
        for i in range(n + 1):
            fast = fast.next

代码：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        dummy_head = ListNode(next=head)  # 创建虚拟头节点
        fast = dummy_head
        slow = dummy_head

        # 快指针比慢指针先走n+1步。这一步对我来说比较难且重要。
        for i in range(n + 1):
            fast = fast.next

        # 移动两个指针，直到快指针指向空
        while fast!=None:
            slow = slow.next
            fast = fast.next

        # 删除的动作
        slow.next = slow.next.next

        return dummy_head.next

面试题 02.07. 链表相交

题目：

        给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

示例：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3

输出：Intersected at '8'

解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。

        从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。 在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

思路：

方法：双指针，让两个指针把两个链表都走一遍，如果有next相等的情况，就相交。

重点：判断相等的是指针，不是数值。

代码：

1、

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        lenA, lenB = 0, 0
        
        cur = headA  # 指向A的头节点
        while cur:
            cur = cur.next
            lenA += 1
            
        cur = headB  # 指向B的头节点
        while cur:
            cur = cur.next
            lenB += 1
            
        curA, curB = headA, headB
        if lenA>lenB:
            curA,curB=curB,curA
            lenA,lenB=lenB,lenA
        for _ in range(lenB-lenA):
            curB=curB.next
        while curA:
            if curA==curB:
                return curA
            else:
                curA=curA.next
                curB=curB.next
        return None

2、在B站中找到相关视频，得到一种简单的操作：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        A=headA
        B=headB
        while A!=B:
            A=A.next if A else headB    # A往后面走，当A指向空，就跳到B上面继续走
            B=B.next if B else headA    #  同上
        return B

142.环形链表II

题目：

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

        如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。

注意：1、pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。2、不允许修改 链表。

示例：

输入：head = [3,2,0,-4], pos = 1

输出：返回索引为 1 的链表节点

解释：链表中有一个环，其尾部连接到第二个节点。

思路：

1、利用快慢指针，开始都指向头节点，后面慢指针每次走一步，快指针走两步。

2、目的是为了找环的起点，第一次相遇后，要把慢指针重新指向头节点，第二次相遇的点就是起点。（目前只能说知道思路，但是感觉理解的不是很透彻。）

代码：

快慢指针方法：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        # 定义快慢指针，开始都指向头节点
        slow = head
        fast = head

        while fast and fast.next:  # 快指针和快指针的下一个结点不为空时
            slow = slow.next
            fast = fast.next.next

            if slow == fast:
                # 当两指针第一次相遇，慢指针指向头节点，这是为了寻找环的起点。
                # 当二者再次相遇，就在环的起点相遇
                slow = head
                while slow != fast:  # 没有相遇，一直往前走，相遇的时候，返回慢指针
                    slow = slow.next
                    fast = fast.next
                return slow
        return None  # 当快指针或者快指针下一个结点指向空，直接返回空

链表的总结

        链表最重要的是要确定数值和指针，要学会巧用虚拟头节点和临时结点。同时双指针的用法也要因题而异。