算法工程师第四天（24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交 142.环形链表II ）

参考文献 代码随想录

一、两两交换链表中的节点

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

示例 1：

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

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

问题分析：

# Definition for singly-linked list.
class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
class Solution(object):
    def swapPairs(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """            
        dummy_haed = ListNode()  # 创建虚拟头节点
        dummy_haed.next = head  # 把它链接起来
        cur = dummy_haed  # 定义一个指针指向虚拟头结点
        while cur.next and cur.next.next:  # 可以反着写吗？不能，因为，如果你先写cur.next.next的话，当cur.next 为 空时，汇报空指针异常
            tmp = cur.next  # 为什么要存储cur.next呢？假设一 cur->1->2->3->4，第一步要变成cur->2->1->3->4，说明cur.next要指向2那么原来的cur.next 的链就断开，无法找到原来cur.next指向的1所以使用tmp先保存起来，然后你观察发现本来有2->3的变成了2->1，说明了原来的链已经断开，也是无法找到，cur.next.next.next的值，所以使用tmp1保存cur.next.next.next
            tmp1 = cur.next.next.next

            cur.next = cur.next.next  # 假设，cur->1->2 变成了 cur->2->1，cur.next = cur.next.next（就是将cur.next 指向了2）

            cur.next.next = tmp  # 假设， cur->1->2 变成了 cur->2->1，cur.next.next = tmp（就是将cur.next 指向了tmp(tmp = 1)）
            cur.next.next.next = tmp1   # 假设， cur->1->2->3 变成了 cur->2->1->3，2->3 到  1->3，tmp1存放的是3
            cur = cur.next.next  # 移动cur，要操作相邻的2个节点，则需要知道第一个节点的前一个节点为多少
        return dummy_haed.next
            

        

二、删除链表的倒数第 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个节点，如果我们每次移动的距离等n那么最后移动的前面距离不就是n了吗?，例如：[2, 5, 6, 7, 2]，假设寻找倒数第二个是多少，我们是不是可以每次移动的距离为2，那么到了最后是不是就是了，如果slow指向的是0这个小标，然后quick也是，然后我们要形成每次移动2的距离，那么就要quick先移动2的距离，那么此时的slow与去quick不就形成了2的移动距离吗，然后slow与quick一起移动，当quick移动到None，那么此时的slow刚好指向倒数第2个，但是我们要删除这个节点，所以slow必须停在倒数第三个，才能更好的删除（单链表）即让quick多移动1步，那就可以是slow刚好落到倒数第三个

# Definition for singly-linked list.
class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
class Solution(object):
    def removeNthFromEnd(self, head, n):
        """
        :type head: ListNode
        :type n: int
        :rtype: ListNode
        """
        dummy_head = ListNode()
        dummy_head.next = head
        quick = dummy_head
        slow = dummy_head
        n += 1
        # 如何找到倒数第n个节点呢，可以quick到slow节点的距离为n来寻找
        # 为什么这样做呢，因为，这样做的话，当quick到了null的时候，那么slow指针也就到了倒数第n节点的前一个节点
        while quick != None and n:
            quick = quick.next
            n -= 1
        while quick != None:
            quick = quick.next
            slow = slow.next
        slow.next = slow.next.next
        return dummy_head.next     
        

三、 链表相交

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

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

示例 1：

输入：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 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

问题分析：题目所的是指针相等，而不是值相等，我们可以把这个拼接在一起，然后例如：listA += listB, listB += listA ，指针同时出发，如果相等，那就返回它此时指向的值（内存地址完全相同的交点）

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

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        if not headA or not headB:
            return None
        
        # 在每个链表的头部初始化两个指针
        pointerA = headA
        pointerB = headB
        
        # 遍历两个链表直到指针相交
        while pointerA != pointerB:
            # 将指针向前移动一个节点
            pointerA = pointerA.next if pointerA else headB  # 当pointerA为null的时候就把headB链表赋值给
            pointerB = pointerB.next if pointerB else headA
        
        # 如果相交，指针将位于交点节点，如果没有交点，值为None
        return pointerA
        

四、环形链表 II

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

        如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

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

示例 2：

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

提示：

• 链表中节点的数目范围在范围 [0, 104] 内
• -105 <= Node.val <= 105
• pos 的值为 -1 或者链表中的一个有效索引

问题分析：判断是否有环，我们可以使用quick和slow指针来移动，如果它们有环，则它们会相等，那么它们每次要移动多少的距离呢？结果是slow每次移动1，而quick每次移动2，为什么quick每次移动2，而不是3， 4， 5，...因为如果你不是2的话，它会跳过slow，就是去quick为2，相当于slow每次移动1步，而slow相当于quick没有移动，然后入口怎么解决呢？这个有点难可以参考代码随想录。

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

class Solution(object):
    def detectCycle(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        slow = head
        quick = head
        
        while quick and quick.next:
            quick = quick.next.next
            slow = slow.next

            if quick == slow:

                index = quick
                index2 = head
                while index != index2:
                    index = index.next
                    index2 = index2.next
                return index
        return None
        

总结链表：感觉就是每次给它加入一个虚拟头结点，会很好的统一操作，针对单链表而言的话，特别要搞清楚删除时和插入时指向问题，就是链表感觉会跟双指针联系在一起，而要考虑的就是每次双指针移动距离的问题。