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

链表part02（23.12.30）

安排：先独立做题，然后看视频讲解，然后看文章讲解，然后再重新做一遍题，把题目AC，最后整理成今日当天的博客。

---

学习时长：四小时
学习内容：自己尝试+pdf说明+视频+力扣题解+自己默写
学习感悟：慢慢能自己独立做题了！虽然用的是笨方法，但是有进步！

---

24. 两两交换链表中的节点

题目链接：力扣题目链接

笔记：

        先定义虚拟头节点，while循环定义两两交换，注意有两个节点可能会没有链接，所以要提前收集好。

提交代码：

# 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: Optional[ListNode]) -> Optional[ListNode]:
        dummyhead = ListNode()
        dummyhead.next = head
        cur = dummyhead
        while cur.next and cur.next.next:
            temp = cur.next
            temp1 = cur.next.next.next
            cur.next = cur.next.next
            cur.next.next = temp
            temp.next = temp1
            cur = cur.next.next
        return dummyhead.next

---

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

题目链接：力扣题目链接

笔记：两种做法，第一种要先获取链表长度，以及注意哪里是循环结束的位置；第二种双指针法，一次性搞定，快指针比慢指针先走n步，这样才能让慢指针指在删除项的前一位时，快指针在最后一位。

提交代码：

        1.自己写的版本

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        #step1: 获取链表长度
        cur, length = head, 0 
        while cur:
            length += 1
            cur = cur.next 
        
        #step2: 删除节点
        dummyhead = ListNode()
        dummyhead.next = head
        cur = dummyhead

        if n < 0 or n > length:
            return 
        
        for i in range(length-n):
            cur = cur.next
        
        cur.next = cur.next.next
        
        return dummyhead.next

        2.双指针 

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        dummyhead = ListNode()
        dummyhead.next = head
        fast, slow = dummyhead, dummyhead

        #step1: 快指针先走n
        for i in range(n):
            fast = fast.next

        #step2: 快慢指针同时往前走
        while fast.next:
            slow = slow.next
            fast = fast.next
        
        #step3: 删除节点
        slow.next = slow.next.next

        return dummyhead.next

过程中报错：自己写代码时 for循环里错把length=n 写成length=n+1了

---

面试题 02.07. 链表相交

题目链接：力扣题目链接

笔记：

        1.简单来说，就是求两个链表交点节点的指针。 这里同学们要注意，交点不是数值相等，而是指针相等。

        2.链表相交的一个特征是：从交点之后的链表长度至少是一样的，所以通过长度可以进行初步比较。两链表尾部对齐以后，开始逐个比较数值，来锁定交点（交点首先数值要是一样的）。

提交代码：

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

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        #step1:先得到两链条各自的长度
        lenA, lenB = 0, 0
        cur = headA
        while cur:
            lenA += 1
            cur = cur.next
        
        cur = headB
        while cur:
            lenB += 1
            cur = cur.next
        
        #step2:让B为长链，并统一两链条长度
        if lenB < lenA:
            headA, headB = headB, headA
            lenA, lenB = lenB, lenA
        
        curA = headA
        curB = headB

        for i in range(lenB-lenA):
            curB = curB.next
        
        #step3:逐一比较数值，找到交点
        while curA != curB:
            curA = curA.next
            curB = curB.next

        if curA == curB:
            return curA
        else:
            return None

疑问：只是长度和统一长度后初始位置数值相同就能保证是交点吗？有没有可能是一种类似X形的链表？？就是说会不会统一长度后又有不一样的？

---

142.环形链表II 

题目链接：力扣题目链接

笔记：

        1.如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。

        2.本题涉及两个问题：判断链表内是否有环；找到环的入口。

        3.用到了双指针方法：快指针每次走两步，慢指针每次走一步，如果存在环，则快慢指针必会相遇。并且确定环的入口时，由于快指针以慢指针的两倍速度在走，那么必然会在慢指针进入环的第一圈时二者相遇（必然是快指针去追慢指针的过程）。        https://code-thinking.cdn.bcebos.com/gifs/141.%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8.gif

        4.通过建立关系式去计算，发现：

        

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

        这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。 

提交代码：

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

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        #step1:判断是否含环
        fast, slow = head, head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                index1 = fast
                #step2:判断开始入环的第一个节点
                index2 = head
                while index1 != index2:
                    index1 = index1.next
                    index2 = index2.next
                return index1
        return None

过程中报错：

        所谓的step2判断开始入环的第一个节点要放在step1的if条件语句里面！！

---

明天是休息日，可以趁机把讲义里前两部分的最后总结看一下，并解决一下本周打卡涉及的疑问。