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

LeetCode 24-两两交换链表的节点

题目：
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

题目链接：
24-两两交换链表的节点

思路：
1.先设置一个虚拟头结点，方便遍历
2.设置快慢指针，一前一后，两两交换

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        new_node = ListNode(next = head) #设置虚拟头结点
        cur = new_node

        while cur.next and cur.next.next: #必须有两个结点才能交换
            fast = cur.next.next
            slow = cur.next
            
            slow.next = fast.next #交换结点
            cur.next = fast
            fast.next = slow

            cur = cur.next.next #继续结点遍历

        return new_node.next

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

题目：
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

进阶：你能尝试使用一趟扫描实现吗？

题目链接：
19. 删除链表的倒数第 N 个结点

思路：
快慢指针，快指针先走k步后，快慢指针同时移动，当快指针走到链表末尾时，慢指针所指结点的下一个结点位置即为要删除结点.

class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        new_node = ListNode(next = head)
        fast = new_node
        slow = new_node
        while n:
            fast = fast.next
            n -= 1
        while fast.next:
            fast = fast.next
            slow = slow.next
        
        slow.next = slow.next.next

        return new_node.next
            

LeetCode 面试题 02.07-链表相交

题目：

题目链接：
面试题 02.07- 链表相交

思路：
1.先将两条链表的尾部对齐，保持两指针的位置
2.在此时两指针位置同时往后遍历，若遇到值相等，则停止遍历，返回所求答案

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> 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

LeetCode 142- 环形链表 II

题目：
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

题目链接：
142-环形链表 II

思路：
1.设置快慢指针，快指针一次走两步，慢指针一次走一步，依次向后遍历，若有环则肯定会相遇
2.在有环的情况下，设置快慢指针相遇结点指针为A，在head设置另一个指针B，两个指针向后走，相遇位置即为所求
具体解释：
代码随想录142.环形链表II

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        slow, fast = head, head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
        
            if fast == slow:
                p = head
                q = fast
                while p != q:
                    p = p.next
                    q = q.next
                return p

        return None

体会：
这几题中，感觉链表相交这题有点难理解，不过这题个人感觉最重要的就是要把两个链表的末端几位对齐，然后两指针向后遍历就好了。总的来说，通过这几题的训练，个人对双指针的理解更加深刻了，用起来更加的得心应手。