1st solution for Double Linked List Construction

Author: wellingtonleitedev

src/linked-list-construction/linked-list-construction.js

@@ -38,108 +38,52 @@ class DoublyLinkedList {
   }
 
   setHead(node) {
-    const next = this.head;
-    if (node.next) node.next.prev = node.prev;
-    if (node.prev) node.prev.next = node.next;
-    this.head.prev = node;
-    this.head = node;
-    this.head.prev = null;
-    this.head.next = next;
+    this.insertBefore(this.head, node);
   }
 
   setTail(node) {
-    const prev = this.tail;
-
-    if (node.prev) node.prev.next = node.next;
-    if (node.next) node.next.prev = node.prev;
-    this.tail.next = node;
-    this.tail = node;
-    this.tail.next = null;
-    this.tail.prev = prev;
+    this.insertAfter(this.tail, node);
   }
 
   insertBefore(node, nodeToInsert) {
-    let currentNodeFromHead = this.head;
-    let currentNodeFromTail = this.tail;
-
-    while (currentNodeFromHead != currentNodeFromTail) {
-      if (node === this.head) this.head = nodeToInsert;
+    this.remove(nodeToInsert);
 
-      if (currentNodeFromHead === node) {
-        nodeToInsert.prev.next = nodeToInsert.next;
-        nodeToInsert.next.prev = nodeToInsert.prev;
+    if (node === this.head) this.head = nodeToInsert;
 
-        nodeToInsert.prev = currentNodeFromHead.prev;
-        nodeToInsert.next = currentNodeFromHead;
-        currentNodeFromHead.prev.next = nodeToInsert;
-        currentNodeFromHead.prev = nodeToInsert;
+    if (!node) return;
 
-        break;
-      }
-
-      if (currentNodeFromTail === node) {
-        nodeToInsert.prev.next = nodeToInsert.next;
-        nodeToInsert.next.prev = nodeToInsert.prev;
-
-        nodeToInsert.prev = currentNodeFromTail.prev;
-        nodeToInsert.next = currentNodeFromTail;
-        currentNodeFromTail.prev.next = nodeToInsert;
-        currentNodeFromTail.prev = nodeToInsert;
-
-        break;
-      }
-
-      currentNodeFromHead = currentNodeFromHead.next;
-      currentNodeFromTail = currentNodeFromTail.prev;
-    }
+    nodeToInsert.prev = node.prev;
+    nodeToInsert.next = node;
+    if (node.prev) node.prev.next = nodeToInsert;
+    node.prev = nodeToInsert;
   }
 
   insertAfter(node, nodeToInsert) {
-    let currentNodeFromHead = this.head;
-    let currentNodeFromTail = this.tail;
-
-    while (currentNodeFromHead != currentNodeFromTail) {
-      if (currentNodeFromHead === node) {
-        if (nodeToInsert.prev) nodeToInsert.prev.next = nodeToInsert.next;
-        if (nodeToInsert.next) nodeToInsert.next.prev = nodeToInsert.prev;
-
-        nodeToInsert.prev = currentNodeFromHead;
-        nodeToInsert.next = currentNodeFromHead.next;
-        if (currentNodeFromHead.next)
-          currentNodeFromHead.next.prev = nodeToInsert;
-        currentNodeFromHead.next = nodeToInsert;
-
-        break;
-      }
-
-      if (currentNodeFromTail === node) {
-        if (node === this.tail) this.tail = nodeToInsert;
-
-        if (nodeToInsert.prev) nodeToInsert.prev.next = nodeToInsert.next;
-        if (nodeToInsert.next) nodeToInsert.next.prev = nodeToInsert.prev;
+    this.remove(nodeToInsert);
 
-        nodeToInsert.prev = currentNodeFromTail;
-        nodeToInsert.next = currentNodeFromTail.next;
-        if (currentNodeFromTail.next)
-          currentNodeFromTail.next.prev = nodeToInsert;
-        currentNodeFromTail.next = nodeToInsert;
+    if (node === this.tail) this.tail = nodeToInsert;
 
-        break;
-      }
+    if (!node) return;
 
-      currentNodeFromHead = currentNodeFromHead.next;
-      currentNodeFromTail = currentNodeFromTail.prev;
-    }
+    nodeToInsert.prev = node;
+    nodeToInsert.next = node.next;
+    if (node.next) node.next.prev = nodeToInsert;
+    node.next = nodeToInsert;
   }
 
   insertAtPosition(position, nodeToInsert) {
     let currentNode = this.head;
+    let currentPosition = 1;
 
     while (currentNode) {
-      if (currentNode.value === value) {
+      if (currentPosition === position) {
+        this.insertBefore(currentNode, nodeToInsert);
+
+        break;
       }
 
       currentNode = currentNode.next;
+      currentPosition += 1;
     }
   }
 
@@ -148,53 +92,46 @@ class DoublyLinkedList {
 
     while (currentNode) {
       if (currentNode.value === value) {
-        if (currentNode === this.head) this.head = currentNode.next;
-        if (currentNode === this.tail) this.tail = currentNode.prev;
-
-        if (currentNode.prev) currentNode.prev.next = currentNode.next;
-
-        if (currentNode.next) currentNode.next.prev = currentNode.prev;
+        this.remove(currentNode);
       }
 
       currentNode = currentNode.next;
     }
   }
 
   remove(node) {
-    let currentNodeFromHead = this.head;
-    let currentNodeFromTail = this.tail;
-
-    while (currentNodeFromHead != currentNodeFromTail) {
-      if (currentNodeFromHead === node) {
-        currentNodeFromHead.prev.next = currentNodeFromHead.next;
-        currentNodeFromHead.next.prev = currentNodeFromHead.prev;
-        break;
-      }
+    this.setHeadOrTail(node);
 
-      if (currentNodeFromTail === node) {
-        currentNodeFromTail.prev.next = currentNodeFromTail.next;
-        currentNodeFromTail.next.prev = currentNodeFromTail.prev;
-        break;
-      }
+    if (node.next) node.next.prev = node.prev;
+    if (node.prev) node.prev.next = node.next;
 
-      currentNodeFromHead = currentNodeFromHead.next;
-      currentNodeFromTail = currentNodeFromTail.prev;
-    }
+    // node.prev = null;
+    // node.next = null;
   }
 
   containsNodeWithValue(value) {
     let currentNode = this.head;
-    let isValueExist = false;
-
-    while (currentNode) {
-      if (currentNode.value === value) {
-        isValueExist = true;
-      }
 
+    while (currentNode && currentNode.value !== value) {
       currentNode = currentNode.next;
     }
 
-    return isValueExist;
+    return !!currentNode;
+  }
+
+  setHeadOrTail(node) {
+    if (this.head === node) {
+      this.head = node.next;
+    }
+
+    if (this.tail === node) {
+      this.tail = node.prev;
+    }
+
+    if (!this.head && !this.tail) {
+      this.head = node;
+      this.tail = node;
+    }
   }
 }
 
@@ -231,10 +168,12 @@ doublyLinkedList.getWholeListFromTail();
 doublyLinkedList.setHead(four);
 doublyLinkedList.setTail(six);
 doublyLinkedList.insertBefore(six, three);
-doublyLinkedList.insertAfter(six, three3);
+doublyLinkedList.insertAfter(six, three2);
+doublyLinkedList.insertAtPosition(1, three3);
 doublyLinkedList.removeNodesWithValue(3);
 doublyLinkedList.remove(two);
 doublyLinkedList.containsNodeWithValue(5);
+doublyLinkedList.containsNodeWithValue(8);
 
 doublyLinkedList.getWholeListFromHead();
 doublyLinkedList.getWholeListFromTail();

src/linked-list-construction/linked-list-construction.test.js

@@ -68,9 +68,9 @@ it("Test Case #1", function () {
   expect(getNodeValuesHeadToTail(linkedList)).toEqual([4, 1, 2, 5, 3, 6, 3]);
   expect(getNodeValuesTailToHead(linkedList)).toEqual([3, 6, 3, 5, 2, 1, 4]);
 
-  // linkedList.insertAtPosition(1, three3);
-  // expect(getNodeValuesHeadToTail(linkedList)).toEqual([3, 4, 1, 2, 5, 3, 6, 3]);
-  // expect(getNodeValuesTailToHead(linkedList)).toEqual([3, 6, 3, 5, 2, 1, 4, 3]);
+  linkedList.insertAtPosition(1, three3);
+  expect(getNodeValuesHeadToTail(linkedList)).toEqual([3, 4, 1, 2, 5, 3, 6, 3]);
+  expect(getNodeValuesTailToHead(linkedList)).toEqual([3, 6, 3, 5, 2, 1, 4, 3]);
 
   linkedList.removeNodesWithValue(3);
   expect(getNodeValuesHeadToTail(linkedList)).toEqual([4, 1, 2, 5, 6]);