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

24. Swap Nodes in Pairs

解法一：顺序交换

•  首先需要创建哑元节点，否则Ian需要单独处理。dummy节点的next指向head，目的是交换完成之后使用dummy.next依然可以得到结果链表
• 创建一个临时指针prev_node，且prev_node=dummy。prev_node一直在待交换的两个节点之前。如果prev的下一个和下下一个节点存在，则可以执行交换代码，否则return结果链表
• 对于每一对需要swap的节点，创建两个临时节点first和second保存他俩。这个时候有了三个节点，分别是prev，first和second。此时按照从屁股到头的顺序进行节点指针重置
  • prev的下一个指针指向second
  • second下一个指针指向first
  • first的一个指针指向second的下一个节点
  • 注：second的下一个节点需要提前保存下来
• 最后返回dummy的next节点，得到结果链表
• 总结：
  • 用到了五个临时指针：dummy，prev，first，second，tmp
  • tmp也可以不用，不过这样从后向前的顺序更好理解，这样的话需要首先使用tmp对下一组节点的开头位置进行记录

class Solution(object):
    def swapPairs(self, head):
        dummy = ListNode(-1)
        dummy.next = head
        
        prev_node = dummy
        
        while head and head.next:
            first_node = head
            second_node = head.next
            
            prev_node.next = second_node
            tmp = second_node.next
            second_node.next = first_node
            first_node.next = tmp
            
            prev_node = first_node
            head = first_node.next
        return dummy.next

 解法2： 递归

• 定义：swapPairs的输入是一对需要交换位置的节点，输入是这对节点的第一个节点，返回的是交换结果
• 创建临时指针first和second，并初始化first=head，second=head.next
• 第一个指针指向的下一个节点是下一对交换好的节点对
• 第二个指针指向的下一个节点是第一个指针
• 返回第二个节点吗，即结果链表的head节点
• 总结：递归需要两个临时指针，first和second

if not head or not head.next:
            return head

        # Nodes to be swapped
        first_node = head
        second_node = head.next

        # Swapping
        first_node.next  = self.swapPairs(second_node.next)
        second_node.next = first_node

        # Now the head is the second node
        return second_node

19. Remove Nth Node From End of List

 解法1：快慢指针

• 首先初始化快指针慢指针在头节点
• 然后使快慢指针之间的距离为n，即快指针先向前走n步
• 然后如果快指针为空了，则说明要删除的是整个链表的第一个元素，因此返回head.next
• 否则只要fast没到链表的最后一个节点，slow和fast都同方向同速度向链表尾部移动
• 当fast到达链表的最后一个节点时，fast的下一个节点是None，这时slow在需要删除的节点的前一个节点。这时候我们只需要将slow的next指针指向下下一个节点即可
• 返回head，得到结果链表

class Solution(object):
    def removeNthFromEnd(self, head, n):
        """
        :type head: ListNode
        :type n: int
        :rtype: ListNode
        """
        slow = fast = head
        k = n
        
        while k > 0:
            fast = fast.next
            k -= 1
        
        if not fast: return head.next    
        
        while fast.next:
            slow = slow.next
            fast = fast.next
        
        slow.next = slow.next.next 
        
        return head

160. Intersection of Two Linked Lists

• 案例：
  • 走所有 A 然后 B：1,2,3,5,6,4,5,6
  • 走所有 B 然后 A：4,5,6,1,2,3,5,6
  • 注意他们是如何在 7 步后一起排在第 5 位的

A) 1  - 2 - 3 -
                     \
                      -  5 -6
B)          4 - /

# 两个链表有交点的问题实际上是链表是否有环的问题
class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        p1 = headA
        p2 = headB
        
        while p1 != p2:
            
            if p1 == None:
                p1 = headB
            else:
                p1 = p1.next
            
            if p2 == None:
                p2 = headA
            else:
                p2 = p2.next
        
        return p1

142. Linked List Cycle II

•  在环中，快指针为什么一定会追上慢指针？因为快指针和慢指针的相对速度为1
• slow和fast相遇之后，slow重新设置为head，然后两个指针相同速度继续走，相遇的节点就是环的入口

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:
                break
        if not fast or not fast.next:
            return None
        slow = head
        while slow != fast:
            fast = fast.next
            slow = slow.next
        return slow