代码营打卡 Day4

1. 两两交换链表节点(24)

首先要改变1的指向, 就必须知道它前一个点的位置, 做出以下的改变才是成功交换了1和2两个节点

所以可知, 在初始情况下, cur应该指向head前一个节点, 即dummyhead点, 才能完成head和下一个点的交换, 所以cur = dummyhead, 并且可知, 如果要交换3、4节点, cur必须在2

接下来判断终止条件, 如果节点为奇数, 那么最后一个节点不需要交换, cur停留在最后一个节点前一个节点, 即cur.next.next = null, 而如果是偶数节点, 那么cur.next.next = null

然后就是记录节点位置调整指向关系, 这里我有个小窍门, 虽然2节点的位置是不需要记录的, 但我还是设置了temp1、2、3, 把节点123的位置都记录下来, 这样指向的时候就不会出现混乱的情况,根据记录下的temp指向就好

下面一个难点就是cur的移动情况, 在移动12的时候, cur在1之前一位, 在移动24的时候, cur到了3之前一位, 即到了2的位置, 所以cur每次是移动两位的 cur = cur.next.next

    def swapPairs(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        dummyhead = ListNode(next = head)
        cur = dummyhead
        while cur.next and cur.next.next:
            temp1 = cur.next
            temp2 = temp1.next
            temp3 = temp2.next
            cur.next = temp2
            temp2.next = temp1
            temp1.next = temp3

            cur = cur.next.next
        return dummyhead.next

2. 删除链表中第n个节点(19)

首先要知道如何定位到第n个节点, 我们先设定一个dummyhead, 这样可以不把删除head的情况单独讨论. 用fast和slow双指针指向dummyhead, fast先移动n个节点, slow开始和fast同时移动, 这时当fast指向null的时候, slow指向的就是第n个节点

但因为要删除第n个节点, 所以要知道第n-1个节点的位置, 所以要让slow指向第n-1个节点, 就让fast节点在第一步中前进n+1个节点即可

之后将slow的next节点指向slow.next.next即完成删除操作

    def removeNthFromEnd(self, head, n):
        """
        :type head: ListNode
        :type n: int
        :rtype: ListNode
        """
        dummyhead = ListNode(0, head)
        fast = dummyhead
        slow = dummyhead
        for i in range(n+1):
            fast = fast.next
        while fast:
            fast = fast.next
            slow = slow.next
        
        slow.next = slow.next.next
        return dummyhead.next

3. 链表相交

这个不太好画, 在pad上画了.

这道题主要思路就是

1. 链表相交是节点一样而不是节点的值一样

2. 确定一个长一点的链表, 然后长的减短的, 将长链表的指针移到和短链表一样长的位置

3. 长链表的指针和短链表表头的指针一起移动, 直到node相同的时候返回, 否则返回none

    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        lenA, lenB = 0, 0
        cur = headA
        while cur:         # 求链表A的长度
            cur = cur.next 
            lenA += 1
        cur = headB 
        while cur:         # 求链表B的长度
            cur = cur.next 
            lenB += 1
        curA, curB = headA, headB

        if lenA > lenB:     # 让curB为最长链表的头，lenB为其长度
            curA, curB = curB, curA
            lenA, lenB = lenB, lenA 
            
        for _ in range(lenB - lenA):  # 让curA和curB在同一起点上（末尾位置对齐）
            curB = curB.next 
        while curA:         #  遍历curA 和 curB，遇到相同则直接返回
            if curA == curB:
                return curA
            else:
                curA = curA.next 
                curB = curB.next
        return None 

4. 环形链表(142)

4.1双指针法

1. 假设快指针每次走2个节点, 慢指针每次走1个节点, 如果链表有环则必定相遇(如果快指针是一次走3个节点, 由于每次比慢指针快2个节点, 则有可能跳过)

2. 

那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。

这里slow指针一定是在第一圈就和fast指针相遇了, 所以不存在x+y+n(z+y)的情况, 因为slow指针走一圈的时间, fast指针可以走两圈, 必定在某个时刻相遇

因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：

(x + y) * 2 = x + y + n (y + z)

两边消掉一个（x+y）: x + y = n (y + z)

因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。

所以要求x ，将x单独放在左面：x = n (y + z) - y ,

再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。

这个公式其实意味着不管index1多走了多少圈, 在相遇的地方开始走一定是可以和从起点出发的index2指针在圈的入口处相遇(写代码也不在乎转了多少圈, 只是index1.next和index2.next最终相遇就可以)

在写代码的时候还有循环边界条件要确定, 因为快指针走在慢指针前面, 所以保证fast != null和 fast.next != null即可(因为快指针一次走两步,所以要看下一步是否为null)

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

4.2 集合法

其实判断有没有环就看一个点有没有走过两遍, 用一个set存储住走过的节点, 记录下第一个重复走的节点即是环的入口

        visited = set()
        index = head
        while (index):
            if index in visited:
                return index
            visited.add(index)
            index = index.next
        return None