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

本文链接：https://blog.csdn.net/ordaaaaaa/article/details/130084820

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

关键要画图！！

tmp值要有两个

# 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(next = head)
        cur = dummyhead
        while cur.next and cur.next.next != None:
            tmp = cur.next
            tmp1 = cur.next.next.next
            cur.next = cur.next.next
            cur.next.next = tmp
            tmp.next = tmp1
            cur = cur.next.next
        return dummyhead.next

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

用到快慢指针，要注意fast为什么要多走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]:
        dummyhead = ListNode()
        dummyhead.next = head
        fast = slow = dummyhead
        while n>=0:   #fast要走n+1步，这样slow指向的就是要删除节点的前一个
            fast = fast.next
            n -= 1
        while fast != None:
            slow = slow.next
            fast = fast.next
        slow.next = slow.next.next
        return dummyhead.next

面试题 02.07. 链表相交

看图解看懂了，到代码没看懂,两个链表走的路径是一样的，链表a走完，跳到链表b的头节点继续走

# 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

画图

while条件要设置好，fast != none and fast.next != none

# 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, slow = head, head
        while fast != None and fast.next != None:
            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