from LinkedList import LinkedList from Node import Node def delete(lst, value): deleted = False if lst.is_empty(): # Check if list is empty -> Return False print("List is Empty") return deleted current_node = lst.get_head() # Get current node previous_node = None # Get previous node if current_node.data is value: lst.delete_at_head() # Use the previous function deleted = True return deleted # Traversing/Searching for Node to Delete while current_node is not None: # Node to delete is found if value is current_node.data: # previous node now points to next node previous_node.next_element = current_node.next_element current_node.next_element = None deleted = True break previous_node = current_node current_node = current_node.next_element if deleted is False: print(str(value) + " is not in list!") else: print(str(value) + " deleted!") return deleted lst = LinkedList() lst.insert_at_head(1) lst.insert_at_head(4) lst.insert_at_head(3) lst.insert_at_head(2) lst.print_list() delete(lst, 4) lst.print_list()
In the above code, look at line no. 22 which says previous_node.next_element = current_node.next_element. Now, though I understand, this line will never get executed for first node since you have handled the condition of deleting first node above, this does not seem to be cleaner code as ideally “previous_node.next_element” cannot exists until it is assigned to current_node which happens only in line 26. Functionality wise this code will work, however, I feel one should avoid writing such a code where there is risk of accessing next_element for an object which is None.
Raising this as I got this as I got a comment on similar code one of my past interviews.