From 6cad5d2e208fc227fb757f17e38ee1ef67aa29b5 Mon Sep 17 00:00:00 2001 From: Abigail Charime Date: Wed, 12 Jan 2022 19:50:42 -0800 Subject: [PATCH] Edited linked-list project --- linked_list/linked_list.py | 232 +++++++++++++++++++++++++++---------- 1 file changed, 170 insertions(+), 62 deletions(-) diff --git a/linked_list/linked_list.py b/linked_list/linked_list.py index 63993214..39fffd13 100644 --- a/linked_list/linked_list.py +++ b/linked_list/linked_list.py @@ -1,79 +1,148 @@ # Defines a node in the singly linked list +from typing import Counter + + class Node: - def __init__(self, value, next_node = None): + def __init__(self, value, next_node=None): self.value = value 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 + self.head = None # keep the head private. Not accessible outside this class + # self.end = None # 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 + else: + 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, next_node=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.value == 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 + current = self.head + length = 0 + + while current: + length += 1 + current = current.next + return length # 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 = self.head + current_index = 0 + + while current: + if current_index == index: + return current.value + current_index += 1 + current = current.next + if current_index < index: + return None # 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): - pass + current = self.head + + while current: + if current.next == None: + return current.value + 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(1) + # Space Complexity: O(1) def add_last(self, value): - pass + new_node = Node(value) + + if self.head == None: + self.head = new_node + return new_node + else: + 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 + current = self.head + if current == None: + return None + max_value = current.value + while current != None: + if max_value < current.value: + max_value = current.value + current = current.next + return max_value # method to delete the first node found with specified value - # Time Complexity: ? - # Space Complexity: ? - def delete(self, value): - pass + # Time Complexity: O(n) + # Space Complexity: O(1) + def delete(self, val): + current = self.head + previous = None + + while current != None: + if current.value == val: + if current.next == None: + previous.next = None + return previous + current.value = current.next.value + current.next = current.next.next + continue + # return current + previous = current + current = current.next + return current # 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 @@ -81,48 +150,87 @@ def visit(self): while current: helper_list.append(str(current.value)) current = current.next - + print(", ".join(helper_list)) # 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 - + previous = None + current = self.head + future = current.next + + while current != None: + future = current.next + current.next = previous + previous = current + current = future + 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 + current = self.head + count = 0 + + while current != None: + count += 1 + current = current.next + middle = int(count/2) - # find the nth node from the end and return its value - # assume indexing starts at 0 while counting to n - # Time Complexity: ? - # Space Complexity: ? + current = self.head + for i in range(0,middle+1): + if i == middle: + return current.value + current = current.next + return self.head + + # # find the nth node from the end and return its value + # # assume indexing starts at 0 while counting to n + # # Time Complexity: O(n) + # # Space Complexity: O(1) def find_nth_from_end(self, n): - pass - - # 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 - - # 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 + current = self.head + count = 0 - # navigate to last node + while current != None: + current = current.next + count += 1 + + if n > count-1: + return None + current = self.head - while current.next != None: + for i in range(0,count): + if (count-1)-i == n: + return current.value current = current.next + return self.head + + # # # 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 + + + + # # # 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 + # current.next = self.head # make the last node link to first node