代码随想录算法训练营第三天 | 203.移除链表元素，707.设计链表，206.反转链表

最新推荐文章于 2024-07-08 22:12:26 发布

我要吃小鱼干

最新推荐文章于 2024-07-08 22:12:26 发布

阅读量137

点赞数

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

本文链接：https://blog.csdn.net/weixin_45348327/article/details/128494897

版权

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

36 篇文章 0 订阅

订阅专栏

203.移除链表元素

题目链接：203.移除链表元素
思路：双指针+虚拟头节点

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

def remove_elements(head: Optional[ListNode], val: int) -> Optional[ListNode]:
    # 新增虚拟节点
    v_head = ListNode(next=head)

    # 单链表删除需要快慢指针
    slow = v_head
    fast = v_head.next

    while fast is not None:
        
        # 删除时，慢指针不动
        if fast.val == val:
            slow.next = fast.next
            fast = slow.next
        
        else:
            slow = slow.next
            fast = fast.next

    return v_head.next

707. 设计链表

题目链接：707. 设计链表
思路：虚拟头节点+链表长度域

class LinkNode:

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


class MyLinkedList:

    def __init__(self):
        self._v_head = LinkNode()  # 虚拟头节点
        self._length = 0

    def get(self, index: int) -> int:
        if index > self._length - 1:
            # index 不合理
            return -1

        p = self._v_head

        while index is not 0:
            p = p.next
            index -= 1
        
        return p.next.val


    def addAtHead(self, val: int) -> None:
        new_node = LinkNode(val)
        new_node.next = self._v_head.next
        self._v_head.next = new_node

        self._length += 1


    def addAtTail(self, val: int) -> None:
        p = self._v_head

        while p.next is not None:
            p = p.next

        new_node = LinkNode(val)
        p.next = new_node

        self._length += 1


    def addAtIndex(self, index: int, val: int) -> None:
        
        # 如果index小于0，则在头部插入节点。
        if index < 0:
            return self.addAtHead(val)
        # 如果 index 等于链表的长度，则该节点将附加到链表的末尾。
        elif index == self._length:
            return self.addAtTail(val)
        # 正常情况
        elif index < self._length:
            p = self._v_head

            while index is not 0:
                p = p.next
                index -= 1
            
            new_node = LinkNode(val)
            new_node.next = p.next
            p.next = new_node

            self._length += 1


    def deleteAtIndex(self, index: int) -> None:

        if index > self._length - 1:
            # index 不合理
            return

        p = self._v_head

        while index is not 0:
            p = p.next
            index -= 1

        p.next = p.next.next

        self._length -= 1

206.反转链表

题目链接：206.反转链表
思路：虚拟头节点+头插法

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

def reverse_list(self, head: Optional[ListNode]) -> Optional[ListNode]:
    new_linklist = ListNode()

    p = head
    while p is not None:
        r = p
        p = p.next

        r.next = new_linklist.next
        new_linklist.next = r
    
    return new_linklist.next