LinkedList Complete Course Added

Author: HuXn-WebDev

4. LinkedList/1. Singly LinkedList/index.js

@@ -0,0 +1,177 @@
+class Node {
+  constructor(value) {
+    this.head = value;
+    this.next = null;
+  }
+}
+
+class LinkedList {
+  constructor(value) {
+    this.head = new Node(value);
+    this.tail = this.head;
+    this.length = 1;
+  }
+
+  push(value) {
+    let newNode = new Node(value);
+
+    if (!this.head) {
+      this.head = newNode;
+      this.tail = newNode;
+    }
+
+    this.tail.next = newNode;
+    this.tail = newNode;
+    this.length++;
+  }
+
+  pop() {
+    if (!this.head) {
+      return undefined;
+    }
+
+    let temp = this.head;
+    let prev = this.head;
+
+    while (temp.next) {
+      // console.log("********** temp", temp);
+      prev = temp;
+      temp = prev.next;
+    }
+
+    // console.log(prev);
+    this.tail = prev;
+    this.tail.next = null;
+    this.length--;
+
+    if (this.length === 0) {
+      this.head = null;
+      this.tail = null;
+    }
+
+    return temp;
+  }
+
+  unshift(value) {
+    const newNode = new Node(value);
+
+    if (!this.head) {
+      this.head = newNode;
+      this.tail = newNode;
+    }
+
+    newNode.next = this.head;
+    this.head = newNode;
+    this.length++;
+    return this;
+  }
+
+  shift() {
+    if (!this.head) {
+      return undefined;
+    }
+
+    // 1. Point to the first node/element
+    let temp = this.head;
+    // 2. Move the head to the next node/element
+    this.head = this.head.next;
+    // 3. Remove first element
+    temp.next = null;
+    this.length--;
+
+    // If we have one node in the list
+    if (this.length === 0) {
+      this.tail = null;
+    }
+
+    return temp;
+  }
+
+  getFirst() {
+    return this.head;
+  }
+
+  getLast() {
+    if (!this.head) {
+      return null;
+    }
+
+    let node = this.head;
+
+    while (node) {
+      // console.log("***********", node);
+      if (!node.next) {
+        return node;
+      }
+      node = node.next;
+    }
+  }
+
+  get(index) {
+    let counter = 0;
+    let node = this.head;
+
+    while (node) {
+      if (counter === index) {
+        return node;
+      }
+
+      counter++;
+      node = node.next;
+    }
+
+    return null;
+  }
+
+  set(index, value) {
+    let temp = this.get(index);
+    console.log("----------", temp);
+
+    if (temp) {
+      temp.value = value;
+      return true;
+    }
+
+    return false;
+  }
+
+  insert(index, value) {
+    if (index === 0) {
+      return this.unshift(value);
+    }
+
+    if (index === this.length) {
+      return this.push(value);
+    }
+
+    const newNode = new Node(value);
+    // Uses the get method to find the node right before the desired position (index - 1).
+    const temp = this.get(index - 1);
+
+    newNode.next = temp.next;
+    temp.next = newNode;
+    this.length++;
+    return true;
+  }
+
+  size() {
+    let counter = 0;
+    let node = this.head;
+
+    while (node) {
+      counter++;
+      node = node.next;
+    }
+
+    return counter;
+  }
+
+  clear() {
+    this.head = null;
+  }
+}
+
+const myLinkedList = new LinkedList(1);
+myLinkedList.push(2);
+myLinkedList.push(3);
+console.log(myLinkedList);

4. LinkedList/2. Doubly LinkedList/index.js

@@ -0,0 +1,93 @@
+class Node {
+  constructor(value) {
+    this.value = value;
+    this.next = null;
+    this.prev = null;
+  }
+}
+
+class DoublyLinkedList {
+  constructor(value) {
+    const newNode = new Node(value);
+    this.head = newNode;
+    this.tail = this.head;
+    this.length = 1;
+  }
+
+  push(value) {
+    const newNode = new Node(value);
+
+    if (!this.head) {
+      this.head = newNode;
+      this.tail = newNode;
+    } else {
+      this.tail.next = newNode;
+      newNode.prev = this.tail;
+      this.tail = newNode;
+    }
+
+    this.length++;
+    return this;
+  }
+
+  pop() {
+    if (this.length === 0) {
+      return undefined;
+    }
+
+    let temp = this.tail;
+
+    if (this.length === 1) {
+      this.head = null;
+      this.tail = null;
+    } else {
+      this.tail = this.tail.prev;
+      this.tail.next = null;
+      temp.prev = null;
+    }
+
+    this.length--;
+    return temp;
+  }
+
+  unshift(value) {
+    const newNode = new Node(value);
+
+    if (this.length === 0) {
+      this.head = newNode;
+      this.tail = newNode;
+    } else {
+      newNode.next = this.head;
+      this.head.prev = newNode;
+      this.head = newNode;
+    }
+
+    this.length++;
+    return this;
+  }
+
+  shift() {
+    if (this.length === 0) {
+      return undefined;
+    }
+
+    let temp = this.head;
+
+    if (this.length === 1) {
+      this.head = null;
+      this.tail = null;
+    } else {
+      this.head = this.head.next;
+      this.head.prev = null;
+      temp.next = null;
+    }
+    this.length--;
+    return temp;
+  }
+}
+
+let myDoublyLinkedList = new DoublyLinkedList(0);
+myDoublyLinkedList.push(1);
+// myDoublyLinkedList.pop();
+// myDoublyLinkedList.shift();
+console.log(myDoublyLinkedList);

4. LinkedList/3. Challenges/1. Reverse LinkedList.js

@@ -0,0 +1,50 @@
+class Node {
+  constructor(value) {
+    this.head = value;
+    this.next = null;
+  }
+}
+
+class LinkedList {
+  constructor(value) {
+    this.head = new Node(value);
+    this.tail = this.head;
+    this.length = 1;
+  }
+
+  push(value) {
+    let newNode = new Node(value);
+
+    if (!this.head) {
+      this.head = newNode;
+      this.tail = newNode;
+    }
+
+    this.tail.next = newNode;
+    this.tail = newNode;
+    this.length++;
+  }
+
+  reverse() {
+    let temp = this.head;
+    this.head = this.tail;
+    this.tail = temp;
+    let next = temp;
+    let prev = null;
+
+    for (let i = 0; i < this.length; i++) {
+      next = temp.next;
+      temp.next = prev;
+      prev = temp;
+      temp = next;
+    }
+
+    return this;
+  }
+}
+
+const myLinkedList = new LinkedList(1);
+myLinkedList.push(2);
+myLinkedList.push(3);
+myLinkedList.push(4);
+console.log(myLinkedList.reverse());