From 5056b1db5ce4953fcdcf7467430f089129a5c834 Mon Sep 17 00:00:00 2001 From: Bahareh Izadpanah Date: Thu, 22 Sep 2022 10:39:14 -0400 Subject: [PATCH 1/2] Finished required functions --- linked_list/linked_list.py | 143 ++++++++++++++++++++++++++++--------- 1 file changed, 111 insertions(+), 32 deletions(-) diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py index 63993214..3de59387 100644 --- a/linked_list/linked_list.py +++ b/linked_list/linked_list.py @@ -13,67 +13,130 @@ 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 not self.head: + 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): - pass + new_node = Node(value) + new_node.next = self.head + self.head = new_node # 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 = self.head + + while current: + if current.val == value: + return True + 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): - pass + + count = 0 + while elem: + elem = elem.next + count += 1 + return count # 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 + current_x = 0 + current_elem = self.head + + while current_x < index: + current_x+=1 + current_elem = current_elem.next + if current_x == index and current_elem: + return current_elem.val + + # 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 + def get_last(self,index): + current_x = 0 + current_elem = self.head + + while current_x < index: + current_x+=1 + current_elem = current_elem.next + if current_x == index and current_elem: + return current_elem.val + # 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 + if not self.head : + self.add_first(value) + else: + + node = Node(value) + current = self.head + while current.next: + current = current.next + current.next = 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 not self.head: + return None + max = self.head.value + current = self.head + while current.next: + current = current.next + if current.value>max.value: + max = current + return max.value + # 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 + current = self.head + previous = None + if not current: + return None + if current.value == value: + self.head = current.next + return + while current: + if current.value == value: + previous.next = current.next + return + previous = current + 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 @@ -86,17 +149,33 @@ 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 + if not self.head: + return None + else: + current =self.head + previous = None + next = 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: ? + # Time Complexity: O(n) + # Space Complexity: O(1) def find_middle_value(self): - pass + before = self.head + after = self.head + while after and after.next: + after = after.next.next + before = before.next + return before.value # find the nth node from the end and return its value # assume indexing starts at 0 while counting to n From 81c5359926158aed10a8eba7f2b5db6019d50d19 Mon Sep 17 00:00:00 2001 From: Bahareh Izadpanah Date: Thu, 22 Sep 2022 11:51:10 -0400 Subject: [PATCH 2/2] All tests passed --- linked_list/linked_list.py | 71 ++++++++++++++++++++------------------ 1 file changed, 38 insertions(+), 33 deletions(-) diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py index 3de59387..0ebca9fc 100644 --- a/linked_list/linked_list.py +++ b/linked_list/linked_list.py @@ -38,7 +38,7 @@ def search(self, value): current = self.head while current: - if current.val == value: + if current.value== value: return True current = current.next @@ -48,12 +48,13 @@ def search(self, value): # Time Complexity: O(n) # Space Complexity: O(1) def length(self): - count = 0 - while elem: - elem = elem.next - count += 1 - return count + current = self.head + + 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 @@ -61,31 +62,32 @@ def length(self): # Time Complexity: O(n) # Space Complexity: O(1) def get_at_index(self, index): - current_x = 0 - current_elem = self.head - - while current_x < index: - current_x+=1 - current_elem = current_elem.next - if current_x == index and current_elem: - return current_elem.val + if index < 0: + return None + else: + current = self.head + count = 0 + while current: + if count == index: + return current.value + current = current.next + count += 1 + return # 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,index): - current_x = 0 - current_elem = self.head - - while current_x < index: - current_x+=1 - current_elem = current_elem.next - if current_x == index and current_elem: - return current_elem.val - + # Time Complexity: O(n) + # Space Complexity: O(1) + def get_last(self): + current = self.head + if not current: + return None + while current.next: + current = current.next + else: + return current.value # method that inserts a given value as a new last node in the linked list # Time Complexity: O(n) @@ -105,15 +107,18 @@ def add_last(self, value): # method to return the max value in the linked list # returns the data value and not the node def find_max(self): - if not self.head: + max = 0 + if self.head == None: return None - max = self.head.value - current = self.head - while current.next: + + current = self.head + while current: + if current.value > max: + max= current.value current = current.next - if current.value>max.value: - max = current - return max.value + + return max + # method to delete the first node found with specified value