刷题第四天 24.交换链表节点 19.删除倒数节点 142.环形链表

24. 交换链表节点

class Solution(object):
    def swapPairs(self, head):
        DummyHead = ListNode(next = head)
        pre = DummyHead
        cur = DummyHead.next
        if (cur == None or cur.next == None):
            return cur
        while(cur.next):
            tmp = cur.next
            cur.next = cur.next.next
            pre.next = tmp
            tmp.next = cur
            pre = cur
            cur = cur.next
            if cur == None:
                break
        return DummyHead.next

链表类的题目纯想容易出错，画图之后就很清楚，交换节点和删除节点类似，断开之前要记录下下一个节点的位置 然后cur节点跳过后面的节点 指向cur.next.next， 然后pre节点指向之前保存的原来的cur.next，然后再让原来的cur.next指向新的cur。

进行交换之后cur已经被向后移动了一格，所以只要让pre更新为现在的cur，cur向后移动一位就行了。

一开始没有AC因为while报错 cur.next是None 因为到最后cur已经是None了，所以加了一个判断 当cur是None的时候直接退出

19. 删除倒数节点

class Solution(object):
    def removeNthFromEnd(self, head, n):
        DummyHead = ListNode(next = head)
        sz = 0
        cur = DummyHead
        while(cur.next):
            cur = cur.next
            sz += 1
        cur = DummyHead
        for i in range (sz - n):
            cur = cur.next
        cur.next = cur.next.next
        return DummyHead.next

暴力解法 先遍历一下多少个节点，然后找到需要删除节点的前一个节点，删除就行

看了视频 很巧妙 利用快慢指针 中间差了n+1步，遍历一次当快指针指向None的时候，慢指针正好指向要删除节点的前一个结点

面试02.07 链表相交

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        Dummy_headA = ListNode(next = headA)
        Dummy_headB = ListNode(next = headB)
        cur_A = Dummy_headA.next
        cur_B = Dummy_headB.next
        size_A = 0
        size_B = 0
        while(cur_A):
            cur_A = cur_A.next
            size_A += 1
        while(cur_B):
            cur_B = cur_B.next
            size_B += 1
        if size_A >= size_B:
            cur_A = Dummy_headA.next
            cur_B = Dummy_headB.next
            for i in range (size_A - size_B):
                cur_A = cur_A.next
            while(cur_A):
                if cur_A == cur_B:
                    return cur_A
                else:
                    cur_A = cur_A.next
                    cur_B = cur_B.next
        if size_A < size_B:
            cur_A = Dummy_headA.next
            cur_B = Dummy_headB.next
            for i in range (size_B - size_A):
                cur_B = cur_B.next
            while(cur_B):
                if cur_A == cur_B:
                    return cur_B
                else:
                    cur_A = cur_A.next
                    cur_B = cur_B.next

先找到两个链表的长度差，然后从相同的位置分别同时移动两个指针，在指针相等的时候返回，注意不是比较val 而是比较指针

142. 环形链表

# 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):
        fast = head
        slow = head
        while(fast and fast.next):
            fast = fast.next.next
            slow = slow.next
            if (slow == fast):
                index1 = slow
                index2 = head
                while(index1 != index2):
                    index1 = index1.next
                    index2 = index2.next
                return index1
        

一开始没想出来，怎么判断链表有环，遍历的时候找不到终止条件，看了视频之后恍然大悟，太巧妙了，循环问题可以用追及的方法来判断，存在环的情况，有速度差就一定会相遇，相遇之后离入口的距离就是入环之前的距离差。