代码随想录算法训练营第四天（py） | 24. 两两交换、 19.删除倒数第N个节点、链表相交、142.环形链表II

24. 两两交换链表中的节点 （normal）

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

思路

两两交换相邻节点，则首先需要进行判断，看cur后面是否有两个节点，如果有才对他俩进行交换。
交换的顺序很简单，按照交换后的节点顺序依次操作即可

# 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: ListNode) -> ListNode:
        dummy_head = ListNode(next=head)
        cur = dummy_head
        # 必须有cur的下一个和下下个才能交换，否则说明已经交换结束了
        while cur.next and cur.next.next:
            temp_back = cur.next  # 1
            temp_front = cur.next.next.next  # 3

            cur.next = cur.next.next  # 0 -> 2
            cur.next.next = temp_back  # 2 -> 1
            cur.next.next.next = temp_front  # 1 -> 3
            cur = cur.next.next  # cur向前移动两步
            
            current = current.next.next  # 移动cur两步，准备开始下一次交换
        return dummy_head.next

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

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

思路1 暴力遍历

最暴力的方法就是先完全遍历一遍，得到链表的长度l，再删除l-n的节点，但这样太代币了。

思路2 快慢指针

弄两个指针，slow用来存储待删除节点的前一个节点，fast用来探路直到尾节点，一开始就让fast比slow领先n+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(0,head)
        slow = dummy_head # 存储待删除节点的前一个节点
        fast = slow # 用来探路
        for i in range(n+1):  # 让fast比slow超前n+1个节点
            fast = fast.next
        while fast:  # 当fast到尾节点时进行最后一次循环
            fast = fast.next
            slow = slow.next

        slow.next = slow.next.next

        return dummy_head.next

面试题 02.07. 链表相交

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

思路

1. 先分别计算两个链表的长度。
2. 根据长度差，让长的链表指针curA前移，使得curA和curB在同一起跑线上。
3. 逐个向后遍历，对比curA和curB，相同则返回结果

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

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        dummy_headA = ListNode(0,headA)
        dummy_headB = ListNode(0,headB)

        curA = dummy_headA
        curB = dummy_headB

        lenA = lenB = 0
        while curA.next:
            lenA +=1
            curA = curA.next
        while curB.next:
            lenB +=1
            curB = curB.next
        
        curA = dummy_headA.next
        curB = dummy_headB.next
        if lenB > lenA:
            # B比A长的情况
            dlen = lenB-lenA
            for i in range(dlen):
                curB = curB.next
            ## 此时AB指针在同一起点，让他们同步向后对比即可
            while curB:
                if curA == curB:
                    return curA
                curA = curA.next
                curB = curB.next

        if lenA >= lenB:
            # A比B长的情况
            dlen = lenA-lenB
            for i in range(dlen):
                curA = curA.next
            ## 此时AB指针在同一起点，让他们同步向后对比即可
            while curA:
                if curA == curB:
                    return curA
                curA = curA.next
                curB = curB.next   

142.环形链表II（normal）

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

思路

这道题包含了数学原理，但是我并不打算完全理解，秉承拿来主义。

1. 要判断是否有环，定义快慢指针，快指针一次走两步，慢指针一次走一步，如果他们相遇，则一定有环。
2. 要判断环的入口，则在他们相遇之后，让慢指针回到头节点，此时两个指针都一次走一步，当他们再次相遇时

# 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
        """
        fast = head
        slow = head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            if fast==slow: #当第一次相遇，让slow回到开头
                slow = head
                while fast != slow:
                    fast = fast.next
                    slow = slow.next
                return slow
        return None