From a575178f06b7adb9919ff56c8db1eb727ea0748a Mon Sep 17 00:00:00 2001 From: sjolivas Date: Sun, 26 Jun 2022 17:45:23 -0500 Subject: [PATCH 1/6] get_first tests pass --- linked_list/linked_list.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py index 63993214..695b4e7c 100644 --- a/linked_list/linked_list.py +++ b/linked_list/linked_list.py @@ -9,14 +9,17 @@ 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 + 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 @@ -90,7 +93,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 66a9d144cc50c648b173d9188d6f8f4799c8af41 Mon Sep 17 00:00:00 2001 From: sjolivas Date: Sun, 17 Jul 2022 12:25:42 -0600 Subject: [PATCH 2/6] Completed more methods --- linked_list/linked_list.py | 50 +++++++++++++++++++++++++++++++------- 1 file changed, 41 insertions(+), 9 deletions(-) diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py index 695b4e7c..adae3842 100644 --- a/linked_list/linked_list.py +++ b/linked_list/linked_list.py @@ -1,5 +1,6 @@ # Defines a node in the singly linked list + class Node: def __init__(self, value, next_node = None): @@ -7,6 +8,7 @@ def __init__(self, value, next_node = None): self.next = next_node # Defines the singly linked list +# Starting off a linked list is always constant time and space complexity. class LinkedList: def __init__(self): self.head = None # keep the head private. Not accessible outside this class @@ -24,17 +26,33 @@ 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): - pass + new_node = Node(value) + new_node.next = self.head + self.head = new_node + + # more compact, not as readable, need to look at the constructor to understand + # self.head references the original linked list that the new head is assigned to + # 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): - pass + # initialize a node pointer + current = self.head + + while current != None: + if current.value == value: + return True # Value was found + + current = current.next + + return False # Value not found # method that returns the length of the singly linked list # Time Complexity: ? @@ -45,10 +63,22 @@ 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: 0(1) def get_at_index(self, index): - pass + if index > 0: + return None + + current_index = 0 + current = self.head + + while current != None and current_index < index: + current = current.next + current_index += 1 + + if current in None: + return current + return current.value # method that returns the value of the last node in the linked list # returns None if the linked list is empty @@ -94,6 +124,8 @@ def visit(self): def reverse(self): pass +# ====================================================================================== + ## Advanced/ Exercises # returns the value at the middle element in the singly linked list # Time Complexity: ? From 5e4f1d142d2ba4acfa7c88e0fc30f7c1c97780cd Mon Sep 17 00:00:00 2001 From: sjolivas Date: Sun, 17 Jul 2022 14:14:27 -0600 Subject: [PATCH 3/6] corrected get_index and added to get_last --- linked_list/linked_list.py | 47 ++++++++++++++++++++++++++++---------- 1 file changed, 35 insertions(+), 12 deletions(-) diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py index adae3842..026fee3f 100644 --- a/linked_list/linked_list.py +++ b/linked_list/linked_list.py @@ -1,6 +1,9 @@ # Defines a node in the singly linked list +from ctypes import pointer + + class Node: def __init__(self, value, next_node = None): @@ -55,10 +58,17 @@ def search(self, value): return False # Value not found # 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 + pointer = self.head + counter = 0 + + while pointer != None: + counter += 1 + pointer = pointer.next + + return counter # method that returns the value at a given index in the linked list # index count starts at 0 @@ -66,26 +76,39 @@ def length(self): # Time Complexity: O(n) # Space Complexity: 0(1) def get_at_index(self, index): - if index > 0: + if index < 0: return None current_index = 0 - current = self.head + pointer = self.head - while current != None and current_index < index: - current = current.next + while pointer != None: + if current_index == index: + return pointer.value + pointer = pointer.next current_index += 1 - if current in None: - return current - 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 + # pointer = self.head + # next_node = pointer.next + + # while next_node != None: + # pointer = next_node + # next_node = pointer.next + + if self.head is None: + return None + + pointer = self.head + + while pointer.next is not None: + pointer = pointer.next + + return pointer.value # method that inserts a given value as a new last node in the linked list # Time Complexity: ? From 789bee6b688d18858f17319601949a0c2cfb3331 Mon Sep 17 00:00:00 2001 From: sjolivas Date: Sun, 17 Jul 2022 15:52:05 -0600 Subject: [PATCH 4/6] added to get_last and find_max, passed tests --- linked_list/linked_list.py | 38 +++++++++++++++++++++++++++++--------- 1 file changed, 29 insertions(+), 9 deletions(-) diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py index 026fee3f..06100d74 100644 --- a/linked_list/linked_list.py +++ b/linked_list/linked_list.py @@ -1,9 +1,6 @@ # Defines a node in the singly linked list -from ctypes import pointer - - class Node: def __init__(self, value, next_node = None): @@ -90,8 +87,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): # pointer = self.head # next_node = pointer.next @@ -111,15 +108,38 @@ def get_last(self): return pointer.value # 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 = self.head + while (last.next): + last = last.next + + last.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.head is None: + return None + + pointer = self.head + maximum = self.head.value + + while (pointer is not None): + if (maximum < pointer.value): + maximum = pointer.value + pointer = pointer.next + + return maximum + # method to delete the first node found with specified value # Time Complexity: ? From 4c2e6c75dcee02e7fe99f80988b62f53958f616a Mon Sep 17 00:00:00 2001 From: sjolivas Date: Sun, 17 Jul 2022 16:07:37 -0600 Subject: [PATCH 5/6] added to delete, passed tests --- linked_list/linked_list.py | 26 ++++++++++++++++++++++---- 1 file changed, 22 insertions(+), 4 deletions(-) diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py index 06100d74..09616ab6 100644 --- a/linked_list/linked_list.py +++ b/linked_list/linked_list.py @@ -118,7 +118,7 @@ def add_last(self, value): return last = self.head - while (last.next): + while last.next: last = last.next last.next = new_node @@ -133,8 +133,8 @@ def find_max(self): pointer = self.head maximum = self.head.value - while (pointer is not None): - if (maximum < pointer.value): + while pointer is not None: + if maximum < pointer.value: maximum = pointer.value pointer = pointer.next @@ -145,7 +145,25 @@ def find_max(self): # Time Complexity: ? # Space Complexity: ? def delete(self, value): - pass + position = self.head + + if position is not None: + if position.value == value: + self.head = position.next + position = None + return + + while position is not None: + if position.value == value: + break + prev = position + position = position.next + + if position == None: + return + + prev.next = position.next + position = None # method to print all the values in the linked list # Time Complexity: ? From ecc0566714830162a57c4abd5fc4fe26ef18304a Mon Sep 17 00:00:00 2001 From: sjolivas Date: Sun, 17 Jul 2022 16:20:23 -0600 Subject: [PATCH 6/6] added to reverse, passed tests --- linked_list/linked_list.py | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py index 09616ab6..1c8b0890 100644 --- a/linked_list/linked_list.py +++ b/linked_list/linked_list.py @@ -142,8 +142,8 @@ def find_max(self): # 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): position = self.head @@ -166,8 +166,8 @@ def delete(self, value): position = None # 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 @@ -180,10 +180,21 @@ 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_node = current.next + + while current: + current.next = prev + prev = current + current = next_node + if next_node: + next_node = next_node.next + + self.head = prev # ======================================================================================