diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py index 63993214..df3da418 100644 --- a/linked_list/linked_list.py +++ b/linked_list/linked_list.py @@ -9,71 +9,150 @@ def __init__(self, value, next_node = None): # Defines the singly linked list class LinkedList: def __init__(self): - self.head = None # keep the head private. Not accessible outside this class + self.head = None # keep the head private. Not accessible outside this class # returns the value in the first node # returns None if the list is empty - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(1) + # Space Complexity: O(1) def get_first(self): - pass - + return None if self.head is None else self.head.value # method to add a new node with the specific data value in the linked list # insert the new node at the beginning of the linked list - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(1) + # Space Complexity: O(1) def add_first(self, value): - pass + new_node = Node(value, self.head) + + self.head = new_node + + return self.head # method to find if the linked list contains a node with specified value # returns true if found, false otherwise - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(n) + # Space Complexity: O(1) def search(self, value): - pass + current_node = self.head + + while current_node: + if current_node.value == value: + return True + current_node = current_node.next + + return False # method that returns the length of the singly linked list - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(n) + # Space Complexity: O(1) def length(self): - pass + current_node = self.head + length = 0 + + while current_node: + length += 1 + current_node = current_node.next + + return length # method that returns the value at a given index in the linked list # index count starts at 0 # returns None if there are fewer nodes in the linked list than the index value - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(n) + # Space Complexity: O(1) def get_at_index(self, index): - pass + if self.head is None: + return None + + current_node = self.head + i = 0 + while i < index and current_node: + current_node = current_node.next + i+=1 + + return current_node.value # method that returns the value of the last node in the linked list # returns None if the linked list is empty - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(n) + # Space Complexity: O(1) def get_last(self): - pass + if self.head is None: + return None + + current = self.head + + while current: + if current.next is None: + return current.value + else: + current = current.next # method that inserts a given value as a new last node in the linked list - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(n) + # Space Complexity: O(1) def add_last(self, value): - pass + new_node = Node(value) + + if self.head is None: + self.head = new_node + return + + last_node = self.head + + while last_node.next: + last_node = last_node.next + + last_node.next = new_node # method to return the max value in the linked list # returns the data value and not the node + # Time Complexity: O(n) + # Space Complexity: O(1) def find_max(self): - pass + if self.head is None: + return None + + current = self.head + max = self.head.value + + while current.next: + if current.next.value > max: + max = current.next.value + current = current.next + else: + current = current.next + + return max # method to delete the first node found with specified value - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(n) + # Space Complexity: O(1) def delete(self, value): - pass + if self.head is None: + return None + + current = self.head + if current.value == value: + self.head = current.next + return + + while current: + if current.value == value: + current = current.next + return + + prev = current + current = current.next + if current.value == value: + prev.next = current.next + return + # method to print all the values in the linked list - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(n) + # Space Complexity: O(n) def visit(self): helper_list = [] current = self.head @@ -86,17 +165,34 @@ def visit(self): # method to reverse the singly linked list # note: the nodes should be moved and not just the values in the nodes - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(n) + # Space Complexity: O(1) def reverse(self): - pass - + prev = None + current = self.head + next = None + + while current: + next = current.next + current.next = prev + prev = current + current = next + self.head = prev + + ## Advanced/ Exercises # returns the value at the middle element in the singly linked list - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(n) + # Space Complexity: O(1) def find_middle_value(self): - pass + slow = self.head + fast = self.head + + while fast and fast.next: + slow = slow.next + fast = fast.next.next + + return slow.value # find the nth node from the end and return its value # assume indexing starts at 0 while counting to n diff --git a/tests/linked_list_test.py b/tests/linked_list_test.py index 58a9d0cf..056deb62 100644 --- a/tests/linked_list_test.py +++ b/tests/linked_list_test.py @@ -197,7 +197,7 @@ def test_reverse_will_reverse_five_element_list(list): for i in range(0, 5): assert list.get_at_index(i) == i -@pytest.mark.skip(reason="Going Further methods") +# @pytest.mark.skip(reason="Going Further methods") def test_find_middle_value_returns_middle_element_of_five_element_list(list): list.add_first(10) list.add_first(30) @@ -206,7 +206,7 @@ def test_find_middle_value_returns_middle_element_of_five_element_list(list): list.add_first(20) assert list.find_middle_value() == 50 -@pytest.mark.skip(reason="Going Further methods") +# @pytest.mark.skip(reason="Going Further methods") def test_find_middle_value_returns_element_at_index_two_of_six_element_list(list): list.add_first(10) list.add_first(30)