refactor: js | linkedlist (#770)

Author: aakhtar3

Diff for: javascript/138-Copy-List-with-Random-Pointer.js

@@ -1,20 +1,65 @@
 /**
+ * https://leetcode.com/problems/copy-list-with-random-pointer/
+ * Time O(N) | Space O(N)
  * @param {Node} head
  * @return {Node}
  */
-var copyRandomList = function (head) {
-    let map = new Map();
-    let ptr = head;
-
-    while (ptr) {
-        // map old - new
-        map.set(ptr, new Node(ptr.val, null, null));
-        ptr = ptr.next;
+var copyRandomList = function(head, map = new Map()) {
+    if (!head) return null;
+    if (map.has(head)) return map.get(head);
+
+    const clone = new Node(head.val);
+
+    map.set(head, clone);                           /*           | Space O(N) */
+    clone.next = copyRandomList(head.next, map);    /* Time O(N) | Space O(N) */
+    clone.random = copyRandomList(head.random, map);/* Time O(N) | Space O(N) */
+
+    return clone;
+}
+
+/**
+ * https://leetcode.com/problems/copy-list-with-random-pointer/
+ * Time O(N) | Space O(1)
+ * @param {Node} head
+ * @return {Node}
+ */
+var copyRandomList = function(head) {
+    if (!head) return null;
+
+    cloneNode(head);         /* Time O(N) */
+    connectRandomNode(head); /* Time O(N) */
+
+    return connectNode(head);/* Time O(N) */
+};
+
+const cloneNode = (curr) => {
+    while (curr) {          /* Time O(N) */
+        const node = new Node(curr.val);
+
+        node.next = curr.next;
+        curr.next = node;
+        curr = node.next;
     }
 
-    for (const [oldptr, newptr] of map) {
-        newptr.next = oldptr.next && map.get(oldptr.next);
-        newptr.random = oldptr.random && map.get(oldptr.random);
+    return curr;
+}
+
+const connectRandomNode = (curr) => {
+    while (curr) {         /* Time O(N) */
+        curr.next.random = curr.random?.next || null;
+        curr = curr.next.next;
     }
-    return map.get(head);
-};
+}
+
+const connectNode = (head) => {
+    let [ prev, curr, next ] = [ head, head.next, head.next ];
+
+    while (prev) {        /* Time O(N) */
+        prev.next = prev.next.next;
+        curr.next = curr?.next?.next || null;
+        prev = prev.next;
+        curr = curr.next;
+    }
+
+    return next
+}

Diff for: javascript/141-Linked-List-Cycle.js

@@ -1,25 +1,36 @@
 /**
- * Definition for singly-linked list.
- * function ListNode(val) {
- *     this.val = val;
- *     this.next = null;
- * }
+ * https://leetcode.com/problems/linked-list-cycle/
+ * Time O(N) | Space O(N)
+ * @param {ListNode} head
+ * @return {boolean}
  */
+var hasCycle = function(head, seen = new Set()) {
+    while (head) {/* Time O(N) */
+        if (seen.has(head)) return true;
+
+        seen.add(head);/* Space O(N) */
+        head = head.next;
+    }
+
+    return false;
+}
 
 /**
+ * https://leetcode.com/problems/linked-list-cycle/
+ * Time O(N) | Space O(1)
  * @param {ListNode} head
  * @return {boolean}
  */
-var hasCycle = function (head) {
-    let set = new Set();
-    while (head) {
-        if (set.has(head)) {
-            return true;
-        } else {
-            set.add(head);
-            head = head.next;
-        }
+var hasCycle = function(head) {
+    let [ slow, fast ] = [ head, head];
+
+    while (fast && fast.next) {/* Time O(N) */
+        slow = slow.next;
+        fast = fast.next.next;
+
+        const hasCycle = slow === fast;
+        if (hasCycle) return true;
     }
 
     return false;
-};
+};

Diff for: javascript/143-Reorder-List.js

@@ -1,49 +1,51 @@
 /**
- * Definition for singly-linked list.
- * function ListNode(val, next) {
- *     this.val = (val===undefined ? 0 : val)
- *     this.next = (next===undefined ? null : next)
- * }
- */
-/**
+ * https://leetcode.com/problems/reorder-list/
+ * Time O(N) | Space O(1)
  * @param {ListNode} head
  * @return {void} Do not return anything, modify head in-place instead.
  */
-var reorderList = function (head) {
-    if (!head) {
-        return;
-    }
+var reorderList = function(head) {
+    const mid = getMid(head);           /* Time O(N) */
+    const reveredFromMid = reverse(mid);/* Time O(N) */
 
-    let slow = head;
-    let fast = head;
+    reorder(head, reveredFromMid);      /* Time O(N) */
+};
+
+const getMid = (head) => {
+    let [ slow, fast ] = [ head, head ];
 
-    // finding the middle of the linked list using 2 pters
-    while (fast && fast.next) {
+    while (fast && fast.next) {         /* Time O(N) */
         slow = slow.next;
         fast = fast.next.next;
     }
 
-    // reverse the second part of the list starting at slow
-    let prev = null;
-    let curr = slow;
-    while (curr) {
-        let next = curr.next;
+    return slow;
+}
+
+const reverse = (head) => {
+    let [ prev, curr, next ] = [ null, head, null ];
+
+    while (curr) {                      /* Time O(N) */
+        next = curr.next;
         curr.next = prev;
+
         prev = curr;
         curr = next;
-    } // here prev is the head
+    }
 
-    // merge two sorted lists (first one starts at head, second at prev)
-    let first = head;
-    let second = prev;
+    return prev;
+}
 
-    while (second.next) {
-        temp = first.next;
+const reorder = (l1, l2) => {
+    let [ first, next, second ] = [ l1, null, l2 ];
+
+    while (second.next) {              /* Time O(N) */
+        next = first.next;
         first.next = second;
-        first = temp;
+        first = next;
 
-        temp = second.next;
+        next = second.next;
         second.next = first;
-        second = temp;
+        second = next;
     }
-};
+}