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

LeetCode 203-移除链表元素

题目：
题意：删除链表中等于给定值 val 的所有节点。

示例 1：
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

示例 2：
输入：head = [], val = 1
输出：[]

示例 3：
输入：head = [7,7,7,7], val = 7
输出：[]

思路： 移动到对应的数值节点，使用‘cur.next = cur.next.next’ 删除该节点

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy_head = ListNode(next = head)
        cur = dummy_head
        while(cur.next != None):
            if(cur.next.val == val):
                cur.next = cur.next.next
            else:
                cur = cur.next
        return dummy_head.next

LeetCode 707-设计链表

题目：
题意：

在链表类中实现这些功能：

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

from re import X
class Node(object):
    def __init__(self, x=0):
        self.val = x
        self.next = None

class MyLinkedList:

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

    def get(self, index: int) -> int:
        if index < 0 or index >= self.size:
            return -1
        cur = self.head.next 
        while(index):
            cur = cur.next
            index -= 1
        return cur.val


    def addAtHead(self, val: int) -> None:
        new_node = Node(val)
        new_node.next = self.head.next
        self.head.next = new_node
        self.size += 1


    def addAtTail(self, val: int) -> None:
        newnode = Node(val)
        cur = self.head
        while(cur.next):
            cur = cur.next
        cur.next = newnode
        self.size += 1


    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0:
            self.addAtHead(val)
            return 
        elif index == self.size:
            self.addAtTail(val)
            return
        elif index > self.size:
            return 
        
        node = Node(val)
        pre = self.head
        while(index):
            pre = pre.next
            index -= 1
        node.next = pre.next
        pre.next = node
        self.size += 1


    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return 
        pre = self.head
        while(index):
            pre = pre.next
            index -= 1
        pre.next = pre.next.next
        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)

LeetCode 206-反转链表

题目：
题意：反转一个单链表。

示例:
输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

提示：使用头插法

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        cur = head
        pre = None
        while (cur != None):
            temp = cur.next
            cur.next = pre
            pre = cur
            cur = temp
        return pre

总结： 今天的内容刚好之前有做过所以感觉比较简单，收获是巩固了头插法的使用。