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

本文链接：https://blog.csdn.net/qq_52149213/article/details/138046219

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

文档讲解：代码随想录

视频讲解：

做题要点

①这个题目中只有两个及两个以上的节点才可以翻转

②在一次翻转中除了要翻转的两个节点，还涉及一个前节点和尾节点

③关键的是先保存两个临时节点，以及循环中cur的移动，cur是要交换的两个节点的前一个节点

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        dummy_head = ListNode(next = head)
        cur = dummy_head
        #只有两个及两个以上的节点才可以翻转
        while cur!=None and cur.next!=None and cur.next.next!= None:
            tmp1 = cur.next
            tmp2 = cur.next.next.next
            cur.next = cur.next.next
            cur.next.next = tmp1
            cur.next.next.next = tmp2
            cur = cur.next.next
        return dummy_head.next

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

文档讲解：代码随想录

题目要点

注意是倒数第 $n$ 个节点，如果是正数第 $n$ 个节点，那么让指针走 $n$ -1步就可以了。但是这里是倒数第 $n$ 个，如果链表的长度是 $l$ ，那么就需要走 $l-n$ 步，关键的问题就是如何知道 $l-n$ 步是多少，因为我们不知道链表的长度 $l$ ，所以我们设计两个指针，让快指针走 $n$ 步，剩下的步数就是 $l-n$ 步了，这时让慢指针开始走，当快指针到达终点时，满指针走的就是 $l-n$ 步了，那么下一个元素就是我们要删除的

class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        #定义快慢指针
        dummy_head = ListNode(next = head)
        fast = dummy_head  #使用虚拟头节点，以防删除的是头节点
        
        slow = dummy_head
        #接下来让快指针走n步
        for i in range(n):
            fast = fast.next
        #接下来让快指针走到末尾
        while fast.next!=None:
            fast = fast.next
            slow = slow.next
        #删除元素
        slow.next = slow.next.next
        return dummy_head.next

面试题 02.07. 链表相交

文档讲解：代码随想录

题目分析

上图为正常情况下，链表相交的情况

链表的长度可能一样，可能不一样。如果链表的长度不一样，那么链表开始相交的位置之后剩下的两个链表的长度肯定是一样的，相交即两个节点指向的下一个节点是同一个节点，如图中 $a2$ 和 $b3$ 两个节点指向的都是 $c1$ ,那么这两个链表相交之后的链表就相当于以 $c1$ 为头节点的链表了

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        #首先计算两个链表的长度
        def length(head):
            len = 0
            cur = head
            while cur != None:
                cur = cur.next
                len = len + 1
            return len
        len_A = length(headA)
        len_B = length(headB)
        curA = headA
        curB = headB
        ###如果两个链表长度不一，我们会让长的链表先走到相等的位置，如果两个链表的长度相差n，则让长链表走n步
        if (len_A - len_B) != 0 :
            if len_A>len_B:
                for i in range((len_A - len_B)):
                    # headA = headA.next #不可以这样写，这样写链表的结构就变了,所以在上面定义两个临时变量
                    curA = curA.next


            else:
                for i in range((len_B - len_A)):
                    curB = curB.next
        while curA!= None:
            if curA == curB:
                return curA
            curA = curA.next
            curB = curB.next
        return None