0

I'm working on this problem: https://leetcode.com/explore/learn/card/linked-list/209/singly-linked-list/1290/

and leetcode is telling me that my code is throwing a runtime error. The input it's trying to make my code run is this:

["MyLinkedList","addAtHead","deleteAtIndex","addAtHead","addAtHead","addAtHead","addAtHead","addAtHead","addAtTail","get","deleteAtIndex","deleteAtIndex"]
[[],[2],[1],[2],[7],[3],[2],[5],[5],[5],[6],[4]]

Where the first array contains the function name and the second contains the function parameters. E.g. the second element adds a 2 at the head of the linkedlist. My question is that how would it be OK to be deleting the element at index 1 when there is only one element in the linkedlist? Is there some special thing about linked lists that I should know or is the input case incorrect. Below is my code for reference.

class SinglyLinkedList():
    def __init__(self):
        self.head = None
        self.tail = None
        self.length = 0
    
    def get(self, index):
        if index<0 or index>self.length: raise AssertionError("get index must be in bounds")

        node = self.head
        for _ in range(index):
            node = node.next
        return node
    
    def addAtHead(self, val):
        node = SinglyListNode(val)
        if self.length==0:
            self.head = node
            self.tail = self.head
        else:
            node.next = self.head
            self.head = node
        self.length+=1
    
    def addAtTail(self, val):
        node = SinglyListNode(val)
        if self.length==0:
            self.tail = node
            self.head = self.tail
        else:
            self.tail.next = node
            self.tail = node
        self.length+=1
    
    def addAtIndex(self, index, val):
        if index<0 or index>self.length:
            raise AssertionError(f"index at which to add ({index}) is out of bounds")
        
        if index==0:
            return self.addAtHead(val)
        if index==self.length:
            return self.addAtTail(val)

        newNode = SinglyListNode(val)

        node = self.head
        for _ in range(index-1):
            node = node.next
        newNode.next = node.next
        node.next = newNode

        self.length+=1

    
    def deleteAtIndex(self, index):
        if index<0 or index>self.length:
            raise AssertionError(f"index at which to add ({index}) is out of bounds")
        
        if index==0:
            self.head = self.head.next
        elif index==self.length-1:
            self.tail=self.get(self.length-2)
        else:
            node = self.head
            for _ in range(index-1):
                node = node.next
            node.next = node.next.next
        self.length-=1

    
    def __str__(self):
        res = "["
        node = self.head
        for _ in range(self.length-1):
            res += str(node)+","
            node = node.next
        res += str(node)+f"] ({self.length})"
        return res
2
  • Is it possible they are counting from 1 instead of 0? Commented May 3, 2021 at 6:21
  • I guess that could be the case. Poor testcase IMO. Commented May 3, 2021 at 6:22

1 Answer 1

2

From https://leetcode.com/problems/design-linked-list/

void deleteAtIndex(int index) Delete the indexth node in the linked list, if the index is valid.

Looks like the delete needs to be done only when the index is valid. Your code needs to handle the case when the index is invalid.

Sign up to request clarification or add additional context in comments.

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.