刷题笔记4-24.两两交换链表中的节点 ， 19.删除链表的倒数第N个节点，面试题 02.07. 链表相交 ，142.环形链表II ，总结

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

24交换不要乱，其余三题都是很好的操作题，19可以调用之前的函数，07看准无环，142快慢指针怎么发现环

---

---

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

题目链接
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

使用头结点

不需要判断首元结点是否存在或者首元.next为None。

# 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]:
        Head= ListNode(next=head)
        H=Head

        while H.next and H.next.next:  # 下一个和下下个不能为空，要交换
            p=H.next     #第一轮交换的开始
            q=H.next.next.next  #下一轮交换的开始
            H.next=p.next
            p.next.next=p
            p.next=q
            H=H.next.next #此处注意，不能搞错写成q
        return Head.next

---

总结

此题一定要画图标注123步骤，指针太多容易乱

---

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

题目链接
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

使用两个指针

使用P和Q指针，框出N+1（单链表用结点前驱删除方便）的距离，然后一起后移，直到P指针指向None，找到要删除的结点的前驱，删除，结束。

# 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]:
        Head=ListNode(next=head)
        p=q=Head
        for _ in range (n+1):
            p=p.next
        while p:
            p=p.next
            q=q.next
        q.next=q.next.next
        return Head.next

---

总结

很灵活的双指针，一个小窗口样子，注意画图和最初行走的步数。

---

3.链表相交

题目链接
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘8’
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

比较法

• 无环，不应考虑中间相同，后面劈叉这种情况（Y型而非X型）
  

# 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:
        pa=headA
        pb=headB
        lena=self.getLength(headA)#别忘了引用
        lenb=self.getLength(headB)
        if lena>lenb:  
            pa,pb=pb,pa
            lena,lenb=lenb,lena  #长的是b，后移到和a一个长度
        for _ in range (lenb-lena):
            pb=pb.next
        while pa:
            if pa==pb:
                return pa
            else:
                pa=pa.next
                pb=pb.next
        return None

    def getLength(self,head:ListNode)->ListNode:
        len=0
        while head:
            len+=1
            head=head.next
        return len    
        

---

总结

还有一种方法，今天看不动了。先学一种

---

4.环形链表II

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

快慢指针法

• 怎么找到环？

# 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]:
        q=p=head
        while p and p.next:
            p=p.next.next #p走两步，q走一步
            q=q.next
            if p==q:
                q=head    #从头结点出发一个指针，
                while q!=p:   #从相遇节点 也出发一个指针,这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。
                    p=p.next
                    q=q.next
                return q
        return None

---

总结

需要推倒，但之前好像看到过类似的题
具体推倒参考

5.链表总结

时隔多日，不好意思。