What are the issues with the following implementation of delete item on an unsorted linked list? You can assume self.head points to the node at the beginning of the list and each node has a link instance variable that refers to the next node in the list (or None if it's the last node).

def __delitem__(self, key) -> None:
    if self.is_empty():
        raise ValueError("Can't delete from an empty list")
        
    previous = None
    current = self.head
    for _ in range(len(self)):
        if current.item == key:
            if current == self.head:
                self.head = self.head.link
            else:
                current.link = previous.link
            length -= 1
        else:
            previous = current
        current = current.link

I have an array-based sorted list and I want to find a target element, where

I have a sorted list implemented using an array. I want to find a target element, which algorithm is the most efficient for this task?

What are the issues with the following implementation of delete item on an unsorted linked list? You can assume self.head points to the node at the beginning of the list and each node has a link instance variable that refers to the next node in the list (or None if it's the last node).

def __delitem__(self, key) -> None:
    if self.is_empty():
        raise ValueError("Can't delete from an empty list")
        
    previous = None
    current = self.head
    for _ in range(len(self)):
        if current.item == key:
            if current == self.head:
                self.head = self.head.link
            else:
                current = previous.link
            length -= 1
        else:
            previous = current
        current = current.link

I have an unsorted linked list and I am implementing an insert() method. Where would the item be inserted for the best-case complexity?

What is the worst-case time complexity of the following function assuming it is measured on value n rather than its logarithmic size?

from array_sorted_list import ArraySortedList
from sorted_list_adt import ListItem
def mystery(n: int) -> None:
    my_list = ArraySortedList(10)
    for i in range(10):
        my_list.add(ListItem(n, i))    # assume ListItem(n, i) is O(1)
        # ListItem(value, key) adds based on key
    for i in range(9, -1, -1):
        my_list.delete(ListItem(n, i))

I have an array-based sorted list implemented with n elements. I want to delete a target element. What is the worst-case time complexity of this?

What are the issues with the following implementation of delete item on an unsorted linked list? You can assume self.head points to the node at the beginning of the list and each node has a link variable that refers to the next node in the list (or None if it's the last node).

def __delitem__(self, key) -> None:
    if self.is_empty():
        raise ValueError("Can't delete from an empty list")
        
    previous = None
    current = self.head
    for _ in range(len(self)):
        if current.item == key:
            current = previous.link
        else:
            previous = current
        current = current.link

I have an unsorted linked list and I am implementing an insert() method. Where would the item be inserted for the worst-case complexity?

What is the worst-case time complexity of the following function assuming it is measured on value n rather than its logarithmic size?

from array_sorted_list import ArraySortedList
from sorted_list_adt import ListItem
def mystery(n: int) -> None:
    my_list = ArraySortedList(n)
    for i in range(n):
        my_list.add(ListItem(n, i)) # assume ListItem(n, i) is O(1)
        # ListItem(value, key) adds based on key