《代码随想录》Day4: 24. 两两交换链表中的节点 + 19.删除链表的倒数第N个节点 + 面试题 02.07. 链表相交 + 142.环形链表II

《代码随想录》Day4

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

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

思路

• 1-2-3：要交换2和3的位置，指针需要指向1，使1-3-2即完成交换
• 应该加一个虚拟头结点，并用临时指针辅助交换
• 重点：如何循环，循环终止条件

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
    	dummyhead = ListNode()    #加一个虚拟头结点
    	dummyhead.next = head
    	cur = dummyhead #临时指针从最开始要交换的head和head.next的前一位开始指向，每次交换后后移两格
    	#循环终止条件：cur.next（当偶数个节点时）或cur.next.next（当奇数个节点时）为空
    	while cur.next and cur.next.next: #此时可以开始交换，想让1-2-3-4-5 变成1-3-2-4-5
    		temp1 = cur.next #保存一份2-3-4-5
    		temp2 = cur.next.next.next #保存一份4-5
    		cur.next = cur.next.next #1-3-4-5：1-3已完成，需要把2加进去
    		cur.next.next = temp1 #1-3-2-3-4-5：2已加进去，要把第二个3删掉
    		cur.next.next.next = temp2 #1-3-2-4-5：完成交换
    		cur = cur.next.next #该轮交换完成，cur向后移动两步
    	return dummyhead.next	

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

删除链表的倒数第 n 个结点，并且返回链表的头结点

思路

• 关键在于找到倒数第n+1个节点，因删倒数第n个节点，则操作指针为该节点上一个
• 要使用dumyhead，可省略对是否头节点的讨论
• 若设定两个指针，快指针先移动N步，此后快慢指针一起移动，当快指针指向null时，慢指针在倒数第N个的位置
• 所以让快指针先移动N+1步，此后快慢指针一起移动，当快指针指向null时，慢指针在倒数第N+1个的位置

class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
    	dummyhead = ListNode(next = head)     	#设立dummyhead
    	fast,slow = dummyhead,dummyhead
    	while fast and n >= 0:  #fast先移n+1步
    		fast = fast.next
    		n -= 1
    	while fast: #两指针一起后移
    		fast = fast.next
    		slow = slow.next
    	slow.next = slow.next.next #此时slow指向倒数n+1个，删除倒数第n个
    	return dummyhead.next
    	

3. Q面试题0207. 链表相交

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

思路

• 即求两个链表交点节点的指针，但交点不是数值相等，而是指针相等
• 先求出两链表长度的差值，让长链表的指针cur A移到与短链表开头的指针cur B末尾对齐的位置，比较curA，curB是否相等，若相等代表该点为交点，若不相等同时后移，相等的点为交点
  

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
        #移动cur A(长的）
        curA = headA
        curB = headB
        if lenA < lenB: #若A短，则令A为B，始终保证A为长链
            lenA, lenB = lenB, lenA
            curA, curB= curB, curA
        #将curA移到headB对应位置，若长度分别为8和4，则curA要移动到长第5位，curB为短链第1位
        m = lenA-lenB #差值为4
        while m > 0:
            curA = curA.next
            m -= 1
        while curA:
            if curA == curB:
                return curA
            else:
                curA = curA.next
                curB = curB.next #A B同时后移，继续寻找交点
        return None #若无相交		

4. Q142.环形链表II

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

判断链表内是否有环

可以用快慢指针法，快指针每次移动2步，慢指针每次一定1步，若它们相遇，则代表链表内有环

如何找到环的入口

思路

• 设链表共有a+b个节点，链表环内有b个节点
• 设有快慢两指针，快指针每次走2步，慢指针每次走1步
  • 若无链表环，两指针不会相遇，返回null
  • 若有链表环，两指针必会相遇，相遇时：快指针走过 f 步，慢指针走过 s 步
    • f = 2s
    • f = s +nb (快指针会比慢指针多走n个环）
    • 则 s = nb
• 从链表头部到环入口的步数是 a+nb
• 当前s = nb，则s再走a步即可到环入口；此时让慢指针和一个新指针（从链表开头走）同时出发走a步即可相遇于环入口

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        fast, slow = head, head #设定快慢指针
        while fast and fast.next:  #设定退出机制，若走到链表末尾还没相遇，则链表内无环，至少3个才能成环，所以走到倒数后两位还未相遇就好了
            fast = fast.next.next #快指针每次两步
            slow = slow.next #慢指针每次一步
            if fast == slow: #若相遇了，再让慢指针和新指针走
                p = head
                q = slow
                while p != q:  #若为相遇则一直往后走
                    p = p.next
                    q = q.next
                return p #相遇时新指针的位置就是链表环开头位置

        return None