From e204895cc82ab7ce40a57e90d1d2880605f7b590 Mon Sep 17 00:00:00 2001 From: Mary Tian Date: Wed, 27 Jul 2022 11:34:01 -0600 Subject: [PATCH 1/2] Updated methods --- linked_list/linked_list.py | 143 ++++++++++++++++++++++++++++++++----- 1 file changed, 126 insertions(+), 17 deletions(-) diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py index 63993214..ebd89ec7 100644 --- a/linked_list/linked_list.py +++ b/linked_list/linked_list.py @@ -7,6 +7,8 @@ def __init__(self, value, next_node = None): self.next = next_node # Defines the singly linked list + + class LinkedList: def __init__(self): self.head = None # keep the head private. Not accessible outside this class @@ -16,7 +18,10 @@ def __init__(self): # Time Complexity: ? # Space Complexity: ? def get_first(self): - pass + if self.head is None: + return None + + return self.head.value # method to add a new node with the specific data value in the linked list @@ -24,52 +29,124 @@ def get_first(self): # Time Complexity: ? # Space Complexity: ? def add_first(self, value): - pass + new_node = Node(value) # make the node + new_node.next = self.head # make the next of new_node the current head + self.head = new_node # assign the head position to the newly-made node + + return self.head.value - # method to find if the linked list contains a node with specified value + # 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: + if current.value == value: + return True + else: + 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: + current = current.next + count += 1 + + return count - # method that returns the value at a given index in the linked list + # 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: ? def get_at_index(self, index): - pass + if index < 0: + return None + + current_index = 0 + current = self.head + + while current and current_index < index: + current = current.next + current_index += 1 + + if current is None: + return None + + return current.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 + current = self.head + if current is None: + return None + + # keep looping until you reach the end of the links + while current.next: + 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: ? def add_last(self, value): - pass + current = self.head + if current is None: + self.head = Node(value, None) + else: + while current: + if current.next == None: + break + current = current.next + + current.next = Node(value, None) # method to return the max value in the linked list # returns the data value and not the node def find_max(self): - pass + current = self.head + if current is None: + return None + 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 + # method to delete the first node found with specified value # Time Complexity: ? # Space Complexity: ? def delete(self, value): - pass + current = self.head + prev = None + if current is None: + return None + + while current: + if current.value == value: + if current == self.head: + self.head = current.next + return + prev.next = current.next + return + prev = current + current = current.next # method to print all the values in the linked list # Time Complexity: ? @@ -89,29 +166,61 @@ def visit(self): # Time Complexity: ? # Space Complexity: ? def reverse(self): - pass + current = self.head + previous = None + + while current: + next = current.next + current.next = previous + previous = current + current = next + + self.head = previous ## Advanced/ Exercises # returns the value at the middle element in the singly linked list # Time Complexity: ? # Space Complexity: ? def find_middle_value(self): - pass + current = self.head + right = self.head + + while current: + if current.next: + current = current.next.next + right = right.next + else: + current = current.next + + return right.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: ? def find_nth_from_end(self, n): - pass + len = self.length() + index = len - n - 1 + + return self.get_at_index(index) - # checks if the linked list has a cycle. A cycle exists if any node in the + +# 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: ? def has_cycle(self): - pass + seen = set() + current = self.head + + while current: + if current in seen: + return True + seen.add(current) + current = current.next + + return False # Helper method for tests # Creates a cycle in the linked list for testing purposes From c70542b5d05015f3996b6245f18cf62b35681d19 Mon Sep 17 00:00:00 2001 From: Mary Tian Date: Wed, 27 Jul 2022 16:38:09 -0600 Subject: [PATCH 2/2] Updated methods, passing tests --- linked_list/linked_list.py | 124 ++++++++++++++----------------------- 1 file changed, 45 insertions(+), 79 deletions(-) diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py index ebd89ec7..1828c184 100644 --- a/linked_list/linked_list.py +++ b/linked_list/linked_list.py @@ -15,95 +15,91 @@ 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): if self.head is 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: ? + # Time Complexity: O(1) + # Space Complexity: O(1) def add_first(self, value): - new_node = Node(value) # make the node - new_node.next = self.head # make the next of new_node the current head - self.head = new_node # assign the head position to the newly-made node + new_node = Node(value) + new_node.next = self.head + self.head = new_node return self.head.value - # method to find if the linked list contains a node with specified 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 = self.head while current: if current.value == value: return True - else: - current = current.next - + current = current.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): current = self.head count = 0 - while current: - current = current.next + while current != None: count += 1 + current = current.next return count - # method that returns the value at a given index in the linked list + # 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 index < 0: - return None - - current_index = 0 + i = 0 current = self.head - while current and current_index < index: + while current: + if i == index: + return current.value current = current.next - current_index += 1 + i += 1 - if current is None: - return None + return None - return current.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): current = self.head - if current is None: + + if not self.head: return None - # keep looping until you reach the end of the links + # keep looping until end of the links while current.next: 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: ? + # Time Complexity: O(1) + # Space Complexity: O(1) def add_last(self, value): current = self.head + if current is None: self.head = Node(value, None) else: @@ -129,13 +125,13 @@ def find_max(self): return max - # method to delete the first node found with specified value - # Time Complexity: ? - # Space Complexity: ? + # method to delete the first node found with specified value + # Time Complexity: O(n) + # Space Complexity: O(1) def delete(self, value): current = self.head prev = None - if current is None: + if not current: return None while current: @@ -149,8 +145,8 @@ def delete(self, value): current = current.next # 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 @@ -163,8 +159,8 @@ 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): current = self.head previous = None @@ -182,56 +178,26 @@ def reverse(self): # Time Complexity: ? # Space Complexity: ? def find_middle_value(self): - current = self.head - right = self.head - - while current: - if current.next: - current = current.next.next - right = right.next - else: - current = current.next - - return right.value + pass # find the nth node from the end and return its value # assume indexing starts at 0 while counting to n # Time Complexity: ? # Space Complexity: ? def find_nth_from_end(self, n): - len = self.length() - index = len - n - 1 - - return self.get_at_index(index) + pass -# checks if the linked list has a cycle. A cycle exists if any node in the + # 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: ? def has_cycle(self): - seen = set() - current = self.head - - while current: - if current in seen: - return True - seen.add(current) - current = current.next - - return False + pass # Helper method for tests # Creates a cycle in the linked list for testing purposes # Assumes the linked list has at least one node def create_cycle(self): - if self.head == None: - return - - # navigate to last node - current = self.head - while current.next != None: - current = current.next - - current.next = self.head # make the last node link to first node + pass \ No newline at end of file