数据结构与算法：链表相关力扣题：203.移除链表元素、707. 设计链表、206. 反转链表、24.两两交换链表中的节点、19. 删除链表的倒数第 N 个结点、142.环形链表 II

最新推荐文章于 2025-06-11 18:07:26 发布

shanshandeisu

最新推荐文章于 2025-06-11 18:07:26 发布

阅读量339

点赞数 15

分类专栏：数据结构与算法 LeetCode 文章标签：链表 leetcode python 数据结构算法

本文链接：https://blog.youkuaiyun.com/zhiaidaidai/article/details/146570046

版权

LeetCode 同时被 2 个专栏收录

55 篇文章

订阅专栏

数据结构与算法

29 篇文章

订阅专栏

203.移除链表元素

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy_head = ListNode(next = head)
        pre = dummy_head
        cur = head
        while cur:
            if cur.val == val:
                pre.next = cur.next
                cur = cur.next
            else:
                pre = pre.next
                cur = cur.next
        return dummy_head.next

效率：0ms，击败100.00%

707. 设计链表

class ListNode:
    def __init__(self, val):
        self.val = val
        self.next = None

class MyLinkedList:
    """
    下标从0开始
    """

    def __init__(self):
        self.size = 0
        self.head = ListNode(0)

    def get(self, index: int) -> int:
        # 注意是index >= self.size
        if index < 0 or index >= self.size:
            return -1 
        cur = self.head
        for _ in range(index+1):
            cur = cur.next
        return cur.val

    def addAtHead(self, val: int) -> None:
        self.addAtIndex(0, val)


    def addAtTail(self, val: int) -> None:
        self.addAtIndex(self.size, val)
        

    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.size:
            return
        pre = self.head
        cur = pre.next
        node = ListNode(val)
        for _ in range(index):
            pre = pre.next
            cur = cur.next
        node.next = cur
        pre.next = node
        self.size += 1


    def deleteAtIndex(self, index: int) -> None:
        if index >= self.size:
            return
        pre = self.head
        cur = pre.next
        for _ in range(index):
            pre = pre.next
            cur = cur.next
        pre.next = cur.next
        self.size -= 1

效率：80ms，击败18.11%

206. 反转链表

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        pre = None
        cur = head
        while cur:
            tmp = cur.next
            cur.next = pre
            pre = cur
            cur = tmp
        return pre

效率：0ms，击败100.00%

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

# 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:
            # cur.next是奇数节点的情况，cur.next.next是偶数节点的情况。
            # 保存节点1
            pre = cur.next
            # 保存节点2
            next_cur = pre.next
            # 保存节点3
            tmp = next_cur.next
            # 虚拟头节点指向节点2
            cur.next = next_cur 
            # 节点2指向节点1
            next_cur.next = pre
            # 节点1指向节点3
            pre.next = tmp
            # cur向后移两位
            cur = cur.next.next
        return dummyhead.next

效率：0ms，击败100.00%

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

# 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]:
        size = 0
        cur = head
        # 计算链条中的节点个数
        while cur:
            cur = cur.next
            size += 1
        # 如果节点个数为1，又因为1<=n<=size，所以返回空
        if size == 1:
            return None
        index = size - n
        # 因为头节点也可能被删，所以加一个虚拟头节点
        dummy_head = ListNode(next = head)
        pre = dummy_head
        cur = head
        for _ in range(index):
            pre = pre.next
            cur = cur.next
        # 此时cur就是要删除的节点
        pre.next = cur.next
        return dummy_head.next

效率：0ms，击败100.00%

142.环形链表 II

觉得抽象的话去看代码随想录的讲解。

这道题非常有意思，用快慢指针来遍历链表，只要两个指针的速度差为1，那么最终一定在环内相遇。
这就解决了第一个问题，如何判断有环。
但是还有第二个问题，就是怎么判断环的入口在哪。
这里的话因为相对速度，所以我们可以看做慢指针进入环后不动，快指针以速度1走一圈，那么此时快指针和慢指针直接的距离不超过一圈（慢指针在环的入口处，快指针在环的任意一个地方），所以快指针会在慢指针走一圈前就追上慢指针。
所以导致快慢两个指针一定在第一圈内相遇。
所以我们设链表头到环入口的距离为x，环入口到两指针相遇点的距离为y，相遇点到环入口的举例为z。
那么存在以下等式

slow_distance = x+y
fast_distance = x+y+n(y+z)
这里 n ≥ 1
又∵ 2 * slow_distance = fast_distance 
∴ x = z
∴ 一个从表头开始走，一个从相遇点开始走，速度都为1时，再次相遇的地方就是环入口

# 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
        while fast and fast.next:
            # 因为快指针是两个两个地向后走的，所以需要fast.next!=None
            # 同时因为快指针比慢指针走得快，所以只需要判断快指针是否为空即可。
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                if_circle = True
                index1 = fast
                # 一个从相遇点出发
                index2 = head 
                # 一个从表头出发
                while index1 != index2:
                # 一起向后走，遇到了的位置就是环入口的位置
                    index1 = index1.next
                    index2 = index2.next
                return index1
        return None