代码随想录刷题day4

24. 两两交换链表中的节点 、19.删除链表的倒数第N个节点 、面试题 02.07. 链表相交、142.环形链表II

1. 两两交换链表中的节点
   1）添加一个虚拟头节点，只有指针指向要交换的两个元素的前一位时，才能顺利交换。
   2）用到三个指针： pre, cur， post。 注意循环停止条件：因为即使最后剩一个元素也不需要继续交换。
   详细图表见代码随想录讲解

代码：

class Solution(object):
    def swapPairs(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        psnode = ListNode(next = head)
        pre = psnode
        while pre.next is not None and pre.next.next is not None:
            cur = pre.next
            post = pre.next.next
            temp = post.next
            pre.next = post
            post.next = cur
            cur.next = temp
            pre = cur

        return psnode.next

2. 19.删除链表的倒数第N个节点
   1）使用快慢指针，一种很巧妙的方式。因为删除节点的话，需要操作节点指向要删除的那个节点的前一个。
   2）快指针先走n步，然后快慢指针一起走，直到快指针.next指向null的时候，慢指针正好指向前一个。

代码：

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        head_dummy = ListNode()
        head_dummy.next = head

        slow, fast = head_dummy, head_dummy
        while(n!=0): #fast先往前走n步
            fast = fast.next
            n -= 1
        while(fast.next!=None):
            slow = slow.next
            fast = fast.next
        #fast 走到结尾后，slow的下一个节点为倒数第N个节点
        slow.next = slow.next.next #删除
        return head_dummy.next

3. 面试题 02.07. 链表相交
   1）采用一种更简单的方式：仍然是双指针。两个指针分别从两个链表头节点开始往后走，遍历完自己之后开始遍历另外一个链表。这样两个指针总会在同一个节点相遇。
   2）如果没有公共节点，那么会同时指向None，也能退出循环。

代码：

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

4. 142.环形链表II
   1）思路比较厉害，记住吧。就是找到快慢指针相交的点a。把a和head节点的中间点作为入圈节点。
   

代码

class Solution(object):
    def detectCycle(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        fast = head
        slow = head
        while fast is not None and fast.next is not None:
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                index1 = head
                index2 = fast
                while index1 != index2:
                    index1 = index1.next
                    index2 = index2.next
                return  index1

        return None