From 0c9ebf3c0775fc2e500e7a8c875354352586fe23 Mon Sep 17 00:00:00 2001 From: Kaylyn Cardella Date: Thu, 30 Sep 2021 23:25:58 -0700 Subject: [PATCH 1/3] first commit --- linked_list/linked_list.py | 102 ++++++++++++++++++++++++++++++++----- 1 file changed, 90 insertions(+), 12 deletions(-) diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py index 63993214..5f6453d0 100644 --- a/linked_list/linked_list.py +++ b/linked_list/linked_list.py @@ -9,35 +9,52 @@ 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: ? def get_first(self): - pass - + return None if self.head == 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: ? 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: ? def search(self, value): - pass + current_node = self.head + + while current_node != None: + 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: ? def length(self): - pass + current_node = self.head + length = 0 + + while current_node != None: + 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 @@ -45,32 +62,93 @@ def length(self): # Time Complexity: ? # Space Complexity: ? def get_at_index(self, index): - pass + if self.length() < index: + return None + + current_node = self.head + i = 0 + while i < index and current_node != None: + 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: ? def get_last(self): - pass + if self.length() == 0: + return None + + current = self.head + + while current != None: + if current.next == 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: ? 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 != None: + 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 def find_max(self): - pass + if self.length() < 1: + return None + + current = self.head + max = self.head.value + + while current.next is not None: + 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: ? def delete(self, value): - pass + if self.head is None: + return None + + current = self.head + + #iterate through the linkedlist + while current != None: + + #if the data is in first node, delete it + if current.value == value: + current = current.next + return + #if the data is in other nodes delete it + 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: ? @@ -90,7 +168,7 @@ def visit(self): # Space Complexity: ? def reverse(self): pass - + ## Advanced/ Exercises # returns the value at the middle element in the singly linked list # Time Complexity: ? From e3071e748793fc6c0f991ccd4eff93a3f1e5d9b6 Mon Sep 17 00:00:00 2001 From: Kaylyn Cardella Date: Fri, 1 Oct 2021 16:29:56 -0700 Subject: [PATCH 2/3] tests passing through delete method --- linked_list/linked_list.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py index 5f6453d0..adcea804 100644 --- a/linked_list/linked_list.py +++ b/linked_list/linked_list.py @@ -132,16 +132,16 @@ def delete(self, value): return None current = self.head + if current.value == value: + self.head = current.next + return - #iterate through the linkedlist while current != None: - #if the data is in first node, delete it if current.value == value: current = current.next return - #if the data is in other nodes delete it prev = current current = current.next if current.value == value: From ba98500cd7f8a5a6913d2c259439d241c69f4d5f Mon Sep 17 00:00:00 2001 From: Kaylyn Cardella Date: Sat, 2 Oct 2021 11:44:57 -0700 Subject: [PATCH 3/3] Tests passing for regular methods and find_middle_value --- linked_list/linked_list.py | 92 +++++++++++++++++++++++--------------- tests/linked_list_test.py | 4 +- 2 files changed, 57 insertions(+), 39 deletions(-) diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py index adcea804..df3da418 100644 --- a/linked_list/linked_list.py +++ b/linked_list/linked_list.py @@ -13,15 +13,15 @@ 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): - return None if self.head == None else self.head.value + 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): new_node = Node(value, self.head) @@ -31,12 +31,12 @@ def add_first(self, value): # 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_node = self.head - while current_node != None: + while current_node: if current_node.value == value: return True current_node = current_node.next @@ -44,13 +44,13 @@ 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_node = self.head length = 0 - while current_node != None: + while current_node: length += 1 current_node = current_node.next @@ -59,15 +59,15 @@ 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): - if self.length() < index: + if self.head is None: return None current_node = self.head i = 0 - while i < index and current_node != None: + while i < index and current_node: current_node = current_node.next i+=1 @@ -75,23 +75,23 @@ 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.length() == 0: + if self.head is None: return None current = self.head - while current != None: - if current.next == None: + 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): new_node = Node(value) @@ -101,21 +101,23 @@ def add_last(self, value): last_node = self.head - while last_node.next != None: + 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): - if self.length() < 1: + if self.head is None: return None current = self.head max = self.head.value - while current.next is not None: + while current.next: if current.next.value > max: max = current.next.value current = current.next @@ -125,8 +127,8 @@ def find_max(self): 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): if self.head is None: return None @@ -136,8 +138,7 @@ def delete(self, value): self.head = current.next return - while current != None: - + while current: if current.value == value: current = current.next return @@ -150,8 +151,8 @@ def delete(self, value): # 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 @@ -164,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)