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

目录

今日任务：

链表理论基础

203.移除链表元素

707.设计链表

 206.反转链表

---

今日任务：

• 链表理论基础
• 203.移除链表元素
• 707.设计链表
• 206.反转链表

---

链表理论基础

链表的定义：

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

删除节点：只需要将上一个节点的next 指向下个节点 （python有自己的内存回收机制，不用手动释放）

性能分析：

---

203.移除链表元素

题目链接：203. 移除链表元素 - 力扣（LeetCode）

分析：

• 定一个虚拟节点，方便统一操作，即使删除头节点也跟删除其他节点一样，不需要特殊分析

# 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)
        
        # 遍历列表并删除值为val的节点
        current = dummy_head
        while current.next:
            if current.next.val == val:
                current.next = current.next.next
            else:
                current = current.next
        
        return dummy_head.next

---

707.设计链表

题目链接：707. 设计链表 - 力扣（LeetCode）

分析：

• 使用双链表
• 对于根据下表插入，需要注意此题的index的含义，index==self.size 已经指出，本题的index的含义

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

class MyLinkedList:
    def __init__(self):
        self.head = None
        self.tail = None
        self.size = 0

    def get(self, index: int) -> int:
        if index < 0 or index >= self.size:
            return -1
        
        if index < self.size // 2:
            current = self.head
            
            for _ in range(index):
                current = current.next
        else:
            current = self.tail
            
            for _ in range(self.size - index - 1):
                current = current.prev
        
        return current.val

    def addAtHead(self, val: int) -> None:
        new_node = ListNode(val=val)
        
        if self.head:
            self.head.prev = new_node
            new_node.next = self.head
        else:
            self.tail = new_node
        
        self.head =  new_node
        self.size += 1

    def addAtTail(self, val: int) -> None:
        new_node = ListNode(val=val)
        
        if self.tail:
            self.tail.next = new_node
            new_node.prev = self.tail
        else:
            self.head = new_node

        self.tail = new_node
        self.size += 1

    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.size:
            return
        
        if index == 0:
            self.addAtHead(val)
        elif index == self.size:
            self.addAtTail(val)
        else:
            if index < self.size // 2:
                current = self.head
                for i in range(index):
                    current = current.next
            else:
                current = self.tail
                for i in range(self.size - index - 1):
                    current = current.prev
            new_node = ListNode(val, current.prev, current)
            current.prev.next = new_node
            current.prev = new_node
            self.size += 1
            
            

    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return

        if index == 0:
            self.head = self.head.next
            
            if self.head:
                self.head.prev = None
            else:
                self.tail = None
        elif index == self.size - 1:
            self.tail = self.tail.prev

            if self.tail:
                self.tail.next = None
            else:
                self.head = None
        else:
            if index < self.size // 2:
                current = self.head

                for _ in range(index):
                    current = current.next
            else:
                current = self.tail

                for _ in range(self.size - index - 1):
                    current = current.prev

            current.prev.next = current.next
            current.next.prev = current.prev

        self.size -= 1 



# Your MyLinkedList object will be instantiated and called as such:
# obj = MyLinkedList()
# param_1 = obj.get(index)
# obj.addAtHead(val)
# obj.addAtTail(val)
# obj.addAtIndex(index,val)
# obj.deleteAtIndex(index)

---

 206.反转链表

题目链接：206. 反转链表 - 力扣（LeetCode）

方法：双指针法

分析：

•  首先定义两个指针prev、current
• while循环当current=None 时结束 返回prev
• while内部：使用temp保存current当前的节点next，之后current.next = prev 达到反转效果之后，prev = current 使prev前移，current=temp使得current前移

# 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]:
        current = head
        prev = None

        while current:
            temp = current.next
            current.next = prev
            prev = current 
            current = temp

        return prev