【代码随想录day4】24. 两两交换链表中的节点 ● 19.删除链表的倒数第N个节点 ● 面试题 02.07. 链表相交 ● 142.环形链表II

最新推荐文章于 2024-10-17 23:22:01 发布

恃丑放旷

最新推荐文章于 2024-10-17 23:22:01 发布

阅读量110

点赞数

分类专栏：代码随想录刷题文章标签：链表数据结构 leetcode

本文链接：https://blog.csdn.net/GeorgeDelta/article/details/130300151

版权

代码随想录刷题专栏收录该内容

17 篇文章 0 订阅

订阅专栏

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

问题

题目链接：https://leetcode.cn/problems/swap-nodes-in-pairs/
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

解答

建议使用虚拟节点（好处太多了）。没什么难度，注意步骤就行，一定要画图辅助。
cur表示当前位置，1，2，3……表示cur之后的位置顺序。
第一步，cur指向2
第二步，2指向1
第三步1指向3

代码：

# 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) # 设置虚拟表头
        pre = dummy_head

        # 当后两个节点存在才能继续
        while pre.next and pre.next.next:
            cur = pre.next
            post = cur.next

            pre.next = post
            cur.next = post.next
            post.next = cur

            pre = pre.next.next
        return dummy_head.next

第二题

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

题目链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

解答

双指针经典运用，设置fast和slow两个指针，fast先移动n步，然后fast和slow一起移动，当fast为None，则删除slow指向的节点。

代码：

# 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)
        
        # 要判断是否为倒数第n个，因此fast要先移动n+1步，
        # 如果此时不+1，fast只会移动到最后一位，不能满足while的判断条件，
        # 实际上[1, 2, 3, 4, (none)]，我们希望fast移动到末尾4后面的一位none
        fast = dummy_head.next
        slow = dummy_head

        for i in range(n):
            fast = fast.next
        
        while fast != None:
            fast = fast.next
            slow = slow.next
        
        slow.next = slow.next.next

        return dummy_head.next

我自己的代码：
倒数n说明之后第n个节点为None，因此先写一个判断后n是否为None的函数，然后移动指针，删除指针下一个节点就行

# 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)
        
        def IsNone(node: Optional[ListNode], n: int):
            while n > 0:
                node = node.next
                n -= 1
            if node == None:
                return False
            else: return True

        pre = dummy_head
        while IsNone(pre.next, n):
            pre = pre.next

        pre.next = pre.next.next

        return dummy_head.next

面试题 02.07. 链表相交

问题

题目链接：https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：
在这里插入图片描述
题目数据保证整个链式结构中不存在环。

注意，函数返回结果后，链表必须保持其原始结构。
示例：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘8’
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

解答

暴力解法可直接两次循环，判断节点的next是否相同，但是会超时
代码：

# 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:
        dummyA = ListNode(next = headA)
        dummyB = ListNode(next = headB)

        curA = dummyA
        curB = dummyB

        while curA:
            curB = dummyB
            while curB:
                if curA.next == curB.next:
                    return curB.next
                else:
                    curB = curB.next
            curA = curA.next
        return None

为了得到一个O(n)的算法，我们可以将两个链表末端对齐，即将长链表的指针移动到剩余元素数量和短链表相等的位置，然后一起移动。
代码：

# 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:
        dummyA = ListNode(next = headA)
        dummyB = ListNode(next = headB)

        sizeA, sizeB = 0, 0
        curA, curB = dummyA, dummyB
        while curA.next:
            sizeA += 1
            curA = curA.next
        while curB.next:
            sizeB += 1
            curB = curB.next

        n = sizeA - sizeB
        curA, curB = dummyA, dummyB
        if n >= 0:
            for i in range(n):
                curA = curA.next
        else:
            for i in range(-n):
                curB = curB.next

        while curA.next != curB.next:
            curA = curA.next
            curB = curB.next
        return curB.next

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

42.环形链表II

问题

题目链接：https://leetcode.cn/problems/linked-list-cycle-ii/
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改链表。

示例：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点

解答

如果存在普通方法找不到停止循环的条件，所以我们首先要想一个能找到停止循环的方法，因此考虑使用双指针，当两个指针满足某个条件时就能停下。
该题有两个难点：1.判断是否有环。2.环的入口在哪

判断是否有环：
可以采用快慢指针，快指针每次移动两个，慢指针移动一个，如果有环快慢指针一定会重合（两个速度不同的人在操场上跑步一定会相遇）。

找到环的入口：
假设从头结点到环形入口节点的节点数为x。环形入口节点到 fast指针与slow指针相遇节点节点数为y。从相遇节点再到环形入口节点节点数为 z。如图所示：
在这里插入图片描述
那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针，（y+z）为一圈内节点的个数A。
因为fast指针是一步走两个节点，slow指针一步走一个节点，所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：

(x + y) * 2 = x + y + n (y + z)

两边消掉一个（x+y）: x + y = n (y + z)

因为要找环形的入口，那么要求的是x，因为x表示头结点到环形入口节点的的距离。

所以要求x ，将x单独放在左面：x = n (y + z) - y ,

再从n(y+z)中提出一个（y+z）来，整理公式之后为如下公式：
x = (n - 1) (y + z) + z (即找到了一个循环停止条件）
注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。

先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。

当 n为1的时候，公式就化解为 x = z。

这就意味着，从头结点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点，那么当这两个指针相遇的时候就是环形入口的节点。

也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。

让index1和index2同时移动，每次移动一个节点，那么他们相遇的地方就是环形入口的节点。

假设快慢指针同时从环入口出发，则快指针一定比慢指针多跑一圈。因此当慢指针进入环内，快指针不在入口的情况，快指针则跑少于一圈，因此，不管怎么样，慢指针在环内一定少于一圈。

代码：

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        fast, slow = head, head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            if slow == fast:
                p = head
                q = slow
                while p != q:
                    p = p.next
                    q = q.next
                return p
        return None