[60天lc] Day3: 203，707，206

203. 移除链表元素

第一次尝试——失败：

class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        fakeHead = ListNode(next = head)
        curr = fakeHead
        while curr.next and curr.next.next:
            if curr.next.val == val :
                curr.next = curr.next.next
            curr = curr.next
        if curr.next and curr.next.val == val:
            curr.next = None
        
        return fakeHead.next

考虑了头尾特殊处理，但是：

• curr.next.next 和尾部处理可以合并，因为curr.next.next即使是None也没有关系，相当于尾部为val的节点直接跳过
• 错误之处在于不是所有情况指针都要向后移一个节点。如果是刚重新连过的链表要先hold一下curr指针的位置继续判断一次，以免连续多个需要移除的节点被漏过

第二次尝试——成功：

class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        fakeHead = ListNode(next = head)
        curr = fakeHead
        while curr.next:
            if curr.next.val == val :
                curr.next = curr.next.next
            else:
                curr = curr.next
        
        return fakeHead.next

707. 设计链表

比较基础, 但还是要搞清楚index向后搜索到了第几个（位置关系）

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


class MyLinkedList(object):

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


    def get(self, index):
        """
        :type index: int
        :rtype: int
        """
        if index >= self.size or index < 0:
            return -1 
        curr = self.head
        for _ in range(index+1): 
            curr = curr.next
        return curr.val


    def addAtHead(self, val):
        """
        :type val: int
        :rtype: None
        """
        self.addAtIndex(0,val)


    def addAtTail(self, val):
        """
        :type val: int
        :rtype: None
        """
        self.addAtIndex(self.size,val)



    def addAtIndex(self, index, val):
        """
        :type index: int
        :type val: int
        :rtype: None
        """
        if index > self.size:
            return 
        
        index = max(0, index)

        pred = self.head 
        for _ in range(index):
            pred = pred.next

        toAdd = ListNode(val)
        toAdd.next = pred.next
        pred.next = toAdd
        self.size += 1


    def deleteAtIndex(self, index):
        """
        :type index: int
        :rtype: None
        """
        if index < 0 or index >= self.size:
            return 
        
        pred = self.head
        for _ in range(index):
            pred = pred.next 
        
        pred.next = pred.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)

206. 反转链表​​​​​​

第一次尝试——失败：

class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        feakeHead = ListNode(next = head)
        prev, curr = feakeHead, head

        while curr:
            nextN = curr.next
            curr.next = prev
            prev = curr 
            curr = nextN
        
        return prev

报错：Error - Found cycle in the ListNode

思路是对的，但是fakeHead造成了环，将FakeHead由节点变为空就好

第二次尝试——成功：

class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        feakeHead = None
        prev, curr = feakeHead, head

        while curr:
            nextN = curr.next
            curr.next = prev
            prev = curr 
            curr = nextN
        
        return prev