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

目录

Leetcode - 24

Leetcode - 19

Leetcode -  面试题 02.07. 链表相交

Leetcode - 142

---

Leetcode - 24

该题就是两两交换相邻位置的节点，那么这里就隐含一个信息就是必要要是一对才能交换，所以在循环时要保证node.next != None的同时，也要保证node.next.next != None, 这里不需要定义两个指针，只需要初始一个指针pre等于dummy（虚拟头结点），然后在循环过程中pre.next为cur，pre.next.next为post即可，为保证节点不被释放，让cur指向post.next，让post指向cur，再让Pre指向post，即可

 def swapPairs(head: Optional[ListNode]) -> Optional[ListNode]:

        if head == None:
            return None
        elif head.next == None:
            return head

        dummy = ListNode(next = head)
        
        prev = dummy

        while prev.next!= None and prev.next.next != None:
            cur = prev.next
            post = prev.next.next

            cur.next = post.next
            post.next = cur
            prev.next = post

            prev = prev.next.next

        return dummy.next

Leetcode - 19

这题是一个双指针的应用，要求倒数第n个节点，可以定义一个快指针和一个慢指针（注意这里快慢不是速度），慢指针差快指针n-1步即可，快指针到末尾时，慢指针即指向倒数第n个位置，(这里可以带入某个值进去，比如n=3, 快指针到最后一个节点，慢指针到倒数第三个节点，中间是差两步，也就是n-1)，但是我们需要删除这个节点，所以要到这个节点的前一个节点，所以是差n步

def removeNthFromEnd(head: Optional[ListNode], n: int) -> Optional[ListNode]:
        dummy = ListNode(next = head)

        slow = dummy
        fast = dummy

        while n:
            fast = fast.next
            n-=1

        while fast.next != None:
            fast = fast.next
            slow = slow.next

        slow.next = slow.next.next

        return dummy.next

这里进行总结一下，要让某个节点走n步，

while n:
      fast = fast.next
      n-=1

若需要到最后一个节点的位置停下：

while node.next != None:

到链表最后一个元素的后一个元素停下：

while node != None:

注意： 到最后一个节点停下，一般是不需要处理最后一个位置的节点，循环结束之后才会到治愈后一个节点，因此循环内的操作不会影响到最后一个节点，若需要处理最后一个节点，则采取如上最后一个循环条件

Leetcode -  面试题 02.07. 链表相交

这题和上一题有点类似，这里两个链表可能存在一长一短两种情况，按照题目的意思，只有可能长链表的靠后的部分和短链表重合，即相交。

 紫色框中部分其实是两个链表重合共用的地方，这里只是为了看得清楚，所以分开画了

所以要找到两个链表相交的部分，所以长的那个链表，起点需要和短的一样，两者的长度差多少，他俩中长的那个链表头结点就需要后移几位

def getIntersectionNode(headA: ListNode, headB: ListNode) -> ListNode:
        if headA == None or headB == None:
            return None

        aLength = 0
        bLength = 0

        dummy_a = ListNode(next = headA)
        dummy_b = ListNode(next = headB)
        
#先计算两个链表的长度，注意这里的技巧，从虚拟头结点出发，head的前一个位置，然后是到链表末尾的后一#个位置结束，这中间的距离刚好就是链表的长度
        while dummy_a.next != None:
            aLength += 1
            dummy_a = dummy_a.next

        while dummy_b.next != None:
            bLength += 1
            dummy_b = dummy_b.next

# 差多少 头结点移动多少
        temp = abs(aLength - bLength)
        if aLength > bLength:
            while (temp):
                headA = headA.next
                temp -= 1
        elif aLength < bLength:
            while (temp):
                headB = headB.next
                temp -= 1

# 我这里是防止出现在某一部分公用节点后，后面又不共用了，找最后一段公用的节点
        res = []
        while headA != None:
#注意这里 一定要是两节点相等，不能仅仅是值相等
            if headA == headB:
                res.append(headA)
            else:
                res = []
            headA = headA.next
            headB = headB.next

        if res == []:
            return None
        else:
            return res[0]

Leetcode - 142

这题不仅仅要判断链表是否有环，还要判断环的入口

这里先看Leetcode - 141 判断是否有环，定义一个快慢指针，快指针每次走两步，慢指针每次走一步，若存在环，则快指针一定能与慢指针相遇

    def hasCycle(head: Optional[ListNode]) -> bool:
        slow = head
        fast = head
        
#这里因为fast每次走两步，为了确保fast.next还有next指针域，所以循环条件里要写fast.next!= None,
# 一般来说 这种要判断后一步或n的条件需要将前n-1步条件都要写进来
#比如 fast.next.next!= None 则需要写 fast.next != None,fast.next!= None。
        while fast!= None and fast.next != None:
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                return True

        else:
            return False

再进入142这道题

首先 和141一样 用快慢指针判断是否有环，再找出口，这里直接用卡哥画好的图

因为指针进入环内就会在环内一直循环，所以快慢指针一定是在环内重合，设慢指针进入环后y距离处与快指针相遇，这个点距离再次回到环的入口距离是z，

有如下关系：

x + y = (x + n * (z + y) + y) / 2,  因为快指针的速度是2，所以右边快指针行走的路程是两倍的慢指针的路程吗，所以要除2，且两指针相遇前，快指针至少已经在环里转1圈了，这里圈数设为n

由于我们要求得是x的大小，所以式子约成

x = n(z+y) - y   进一步的 x = (n-1)(z+ y) + z   ,这里 z+y就是环的长度

当快指针仅仅比慢指针多跑一圈时，n = 1  ，x = z，所以此时，从头结点出发，和从相遇点出发，速度一致时可同时到达环的入口处，到其实我们想想，若n！=1时，可以想象为x 这段距离很长，x的大小比z 还要大很多圈(z +y)，所以 不论是从相遇点出发z的距离，与从头节点出发的同速节点在入口相遇，还是多走几圈，都是会是在入口处相遇

def detectCycle(head: Optional[ListNode]) -> Optional[ListNode]:
        slow = head
        fast = head

        while fast!= None and fast.next != None:
            slow = slow.next
            fast = fast.next.next

            if slow == fast:
#相遇后，定义两个新指针，分别从相与处和头结点出，以相同速度出发，总能在环的入口处相遇
                node1 = head
                node2 = slow
                while node1 != node2:
                    node1 = node1.next
                    node2 = node2.next
                return node1

        else:
            return None