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

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

# 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]:
        dummy_head = ListNode(next=head)
        current=dummy_head
        while current.next and current.next.next:
            temp = current.next
            temp1 = current.next.next.next
            current.next=current.next.next
            current.next.next=temp
            temp.next=temp1
            current = current.next.next
        return dummy_head.next

 个人经验：

注意保存临时节点，防止变化改变，脑海里要有图

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

快慢指针

# 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]:
        dummy_head = ListNode(next=head)
        fast = dummy_head
        slow = dummy_head
        n+=1
        while n and fast!=None:
            fast = fast.next
            n-=1
        while fast:
            fast = fast.next
            slow = slow.next
        slow.next = slow.next.next
        return dummy_head.next

 解题技巧：

快慢指针的距离与末尾之间的距离是关键

面试题 02.07. 链表相交

# 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:
        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 

        

解题技巧：

关键是在统一起跑线，要节点相同而不是值相等

142.环形链表II

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


        

 解题技巧：

两者快慢指针距离循环点相同，这想清楚了问题就迎刃而解了

坚持

坚持

坚持就是胜利！！！

蓝桥杯准备中......