Linked List Assignment

.vscode/launch.json

@@ -0,0 +1,7 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": []
+}

lib/linked-list.js

@@ -7,9 +7,10 @@ class Node {
 }
 // Defines the singly linked list
 class LinkedList {
-    // keep the head private. Not accessible outside this class
+    // keep the #head private. Not accessible outside this class
     // note that this language feature is only available from Node 12 on
     // #head;
+    #head 
     constructor() {
         // The # before the variable name indicates
         //   a private variable.
@@ -19,148 +20,232 @@ class LinkedList {
     /* 
     Method to retrieve the value in the first node.
     returns null if the list is empty.
-    Time Complexity: ?
-    Space Complexity: ?
+    Time Complexity: O(1)
+    Space Complexity: O(1)
     */
     getFirst() {
-        throw new Error('This method has\'t been implemented yet!')
+        return (!this.#head)? null:this.#head
     }
 
     /*
     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)
     */
     addFirst(value) {
-        throw new Error("This method hasn't been implemented yet!");
+        let newNode = new Node(value)
+        if (!this.#head) {
+            this.#head = newNode
+        } else {
+            newNode.next = this.#head
+            this.#head = newNode
+        }
     }
 
     /*
     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)
     */
     search(value) {
-        throw new Error("This method hasn't been implemented yet!");
+        let current = this.#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)
      */
     length() {
-        throw new Error("This method hasn't been implemented yet!");
+        let count = 0;
+        let current = this.#head;
+        while (current) {
+            count ++
+            current = current.next
+            if (current == this.#head){
+                return count
+            }
+        }
+        return count   
     }
 
     /*
     method that returns the value at a given index in the linked list
     index count starts at 0
     returns nil 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)
      */
     getAtIndex(index) {
-        throw new Error("This method hasn't been implemented yet!");
+        let count = 0;
+        let current = this.#head;
+        while (current) {
+            if (count === index) {
+                return current.value
+            } else {
+                count ++
+                current = current.next
+            }
+        }
+        return null
     }
 
     /*
     method that returns the value of the last node in the linked list
     returns nil if the linked list is empty
-    Time Complexity: ?
-    Space Complexity: ?
+    Time Complexity: O(n)
+    Space Complexity: O(1)
     */
     getLast() {
-        throw new Error("This method hasn't been implemented yet!");
+        let current = this.#head;
+        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(n)
+    Space Complexity: O(1)
     */
     addLast(value) {
-        throw new Error("This method hasn't been implemented yet!");
+        if (!this.#head) {
+            this.#head = new Node(value)
+        } else {
+            let current = this.#head;
+            while (current.next) {
+                current = current.next
+            }
+            current.next = new Node(value)
+        }
     }
 
     /*
     method to return the max value in the linked list
     returns the data value and not the node
-    Time Complexity: ?
-    Space Complexity: ?
+    Time Complexity: O(n)
+    Space Complexity: O(1)
     */
     findMax() {
-        throw new Error("This method hasn't been implemented yet!");
+        if (!this.#head) {
+            return null
+        }
+        let max = this.#head.value
+        let current = this.#head;
+        while (current) {
+            (current.value>max)? (max = current.value):
+            current = current.next
+        }
+        return max;
     }
 
     /*
     method to delete the first node found with specified value
-    Time Complexity: ?
-    Space Complexity: ?
+    Time Complexity: O(n)
+    Space Complexity: O(1)
     */
     delete(value) {
-        throw new Error('This method has\'t been implemented yet!')
+        (this.#head?.value === value)?(this.#head = this.#head.next):false;
+        let current = this.#head
+        while (current) {
+            (current.next?.value === value)? (current.next = current.next.next):
+            current = current.next
+        }
     }
+
 
     /*
     method to print all the values in the linked list
-    Time Complexity: ?
-    Space Complexity: ?
+    Time Complexity: O(n)
+    Space Complexity: O(1)
     */
     visit() {
         const helper_list = []
-        current = this.#head;
-
+        let current = this.#head;
         while (current) {
             helper_list.push(current.value);
             current = current.next;
         }
 
-        console.log(helper_list.toString());
+        console.log(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)
     */
     reverse() {
-        throw new Error("This method hasn't been implemented yet!");
+        let current = this.#head
+        let prev
+        let next
+        while (current) {
+            if (current===this.#head) {
+                prev = current
+                current = current.next
+            } else {
+                next = current.next
+                current.next = prev
+                prev = current
+                current = next
+            }
+        }
+        this.#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)
      */
     findMiddleValue() {
-        throw new Error("This method hasn't been implemented yet!");
+        let len = this.length()
+        const evenCheck = len%2
+        return evenCheck ? this.getAtIndex(Math.floor(len/2)):(this.getAtIndex((len/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: ?
+    Time Complexity: O(n)
+    Space Complexity: O(1)
     */
     findNthFromEnd(n) {
-        throw new Error("This method hasn't been implemented yet!");
+        return(this.getAtIndex(this.length()-n))
     }
 
     /*
     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: ?
+    Time Complexity: O(n)
+    Space Complexity: O(1)
     */
     hasCycle() {
-        throw new Error("This method hasn't been implemented yet!");
+        let current = this.#head;
+        let count = 0;
+        while (current) {
+            count ++
+            current = current.next
+            if (current.next == this.#head){
+                return true
+            }
+        }
+        return false
     }
 
     /*