From d5c773a9d58e24eeca24d7bee36cb15e0571a34b Mon Sep 17 00:00:00 2001 From: Lilly Date: Sat, 9 Jul 2022 18:36:27 -0700 Subject: [PATCH 1/2] Lilly --- linked_list/linked_list.py | 163 +++++++++++++++++++++++++++++++++---- tests/linked_list_test.py | 12 +-- 2 files changed, 152 insertions(+), 23 deletions(-) diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py index 63993214..963b96f2 100644 --- a/linked_list/linked_list.py +++ b/linked_list/linked_list.py @@ -13,31 +13,46 @@ def __init__(self): # 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 + if self.head == None: + return None + return 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: ? def add_first(self, value): - pass + self.head = Node(value, 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: ? def search(self, value): - pass + current = self.head + + while current != None: + if current.value == value: + return True + current = current.next + return False # method that returns the length of the singly linked list # Time Complexity: ? # Space Complexity: ? def length(self): - pass + current = self.head + + count = 0 + while current != None: + current = current.next + count += 1 + + return count # method that returns the value at a given index in the linked list # index count starts at 0 @@ -45,31 +60,93 @@ def length(self): # Time Complexity: ? # Space Complexity: ? def get_at_index(self, index): - pass + current = self.head + + count = 0 + while current: + if count == index: + return current.value + count += 1 + current = current.next + + return None + + # method that returns the index of the first node with the given value + # returns -1 if the value is not found in the linked list + # Time Complexity: O(n)? + # Space Complexity: O(1)? + # 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: ? def get_last(self): - pass + + if self.head == None: + return None + + current = self.head + + while current.next != None: + current = current.next + + return current.value # method that inserts a given value as a new last node in the linked list # Time Complexity: ? # Space Complexity: ? + #method to add node to the end of the linked list def add_last(self, value): - pass + current = self.head + if current is None: + self.head = Node(value) + return + while current.next != None: + current = current.next + current.next = Node(value) + # method to return the max value in the linked list # returns the data value and not the node def find_max(self): - pass + if self.head == None: + return None + + current = self.head + + max = 0 + while current: + if current.value > max: + max = current.value + current = current.next + + return max # method to delete the first node found with specified value # Time Complexity: ? # Space Complexity: ? def delete(self, value): - pass + current = self.head + + if current is not None: + if current.value == value: + self.head = current.next + temp = None + return + + while current is not None: + if current.value == value: + break + prev = current + current = current.next + + if current == None: + return None + + prev.next = current.next + + current = None # method to print all the values in the linked list # Time Complexity: ? @@ -86,24 +163,64 @@ 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 + while current is not None: + 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: ? + # find middle value of a singly linked list def find_middle_value(self): - pass + if self.head == None: + return None + + current = self.head + count = 0 + while current: + count += 1 + current = current.next + + current = self.head + for i in range(count // 2): + current = current.next + + return current.value + + # find the nth node from the end and return its value # assume indexing starts at 0 while counting to n # Time Complexity: ? # Space Complexity: ? + # find nth node from the end of the linked list def find_nth_from_end(self, n): - pass + if self.head == None: + return None + + current = self.head + count = 0 + while current: + count += 1 + current = current.next + + current = self.head + for i in range(count - n): + current = current.next + + return current.value + + + # checks if the linked list has a cycle. A cycle exists if any node in the # linked list links to a node already visited. @@ -111,7 +228,19 @@ def find_nth_from_end(self, n): # Time Complexity: ? # Space Complexity: ? def has_cycle(self): - pass + if self.head == None: + return False + + current = self.head + visited = set() + + while current: + if current in visited: + return True + visited.add(current) + current = current.next + + return False # Helper method for tests # Creates a cycle in the linked list for testing purposes diff --git a/tests/linked_list_test.py b/tests/linked_list_test.py index 58a9d0cf..ee007611 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) @@ -216,11 +216,11 @@ def test_find_middle_value_returns_element_at_index_two_of_six_element_list(list list.add_first(100) assert list.find_middle_value() == 60 -@pytest.mark.skip(reason="Going Further methods") +# @pytest.mark.skip(reason="Going Further methods") def test_nth_from_n_when_list_is_empty(list): assert list.find_nth_from_end(3) == None -@pytest.mark.skip(reason="Going Further methods") +# @pytest.mark.skip(reason="Going Further methods") def test_find_nth_from_n_when_length_less_than_n(list): list.add_first(5) list.add_first(4) @@ -230,7 +230,7 @@ def test_find_nth_from_n_when_length_less_than_n(list): assert list.find_nth_from_end(6) == None -@pytest.mark.skip(reason="Going Further methods") +# @pytest.mark.skip(reason="Going Further methods") def test_find_nth_from_n(list): list.add_first(1) list.add_first(2) @@ -243,7 +243,7 @@ def test_find_nth_from_n(list): assert list.find_nth_from_end(3) == 4 assert list.find_nth_from_end(4) == None -@pytest.mark.skip(reason="Going Further methods") +# @pytest.mark.skip(reason="Going Further methods") def test_has_cycle(list): assert list.has_cycle() == False From 2516de0a02f05a0a3db736bed103233aedd5c5d0 Mon Sep 17 00:00:00 2001 From: Lilly Date: Fri, 15 Jul 2022 00:25:33 -0700 Subject: [PATCH 2/2] repushing for feedback/update grade --- linked_list/linked_list.py | 42 ++++++++++++++++++++------------------ 1 file changed, 22 insertions(+), 20 deletions(-) diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py index 963b96f2..1df84f78 100644 --- a/linked_list/linked_list.py +++ b/linked_list/linked_list.py @@ -23,15 +23,15 @@ def get_first(self): # 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): self.head = Node(value, 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): current = self.head @@ -42,8 +42,8 @@ def search(self, value): 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): current = self.head @@ -57,8 +57,8 @@ def length(self): # 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): current = self.head @@ -79,8 +79,8 @@ def get_at_index(self, index): # 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): if self.head == None: @@ -94,8 +94,8 @@ def get_last(self): return current.value # method that inserts a given value as a new last node in the linked list - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: On + # Space Complexity: O(1) #method to add node to the end of the linked list def add_last(self, value): current = self.head @@ -109,6 +109,8 @@ def add_last(self, value): # method to return the max value in the linked list # returns the data value and not the node + # Time Complexity: O1 + # Space Complexity: O1 def find_max(self): if self.head == None: return None @@ -149,8 +151,8 @@ def delete(self, value): current = None # method to print all the values in the linked list - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O1 + # Space Complexity: ON def visit(self): helper_list = [] current = self.head @@ -177,8 +179,8 @@ def reverse(self): ## Advanced/ Exercises # returns the value at the middle element in the singly linked list - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(n) + # Space Complexity: On # find middle value of a singly linked list def find_middle_value(self): if self.head == None: @@ -200,8 +202,8 @@ def find_middle_value(self): # find the nth node from the end and return its value # assume indexing starts at 0 while counting to n - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(n) + # Space Complexity: O(1) # find nth node from the end of the linked list def find_nth_from_end(self, n): if self.head == None: @@ -225,8 +227,8 @@ def find_nth_from_end(self, n): # checks if the linked list has a cycle. A cycle exists if any node in the # linked list links to a node already visited. # returns true if a cycle is found, false otherwise. - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(n) + # Space Complexity: O(1) def has_cycle(self): if self.head == None: return False