refactored from ES6 classes to ES6 factory function to Linked List Data Strucutre

Author: crizstian

06-chapter-Linked-List/06-chapter-1-Linked-List.js

@@ -0,0 +1,97 @@
+// Node Linked List member class example
+class Node {
+  constructor(element = 'Head', next = null) {
+    this.element = element;
+    this.next    = next;
+  }
+}
+
+// Linked List data structure class example
+class LList {
+  constructor(head = new Node()) {
+    this.head = head;
+    this.current = this.head;
+  }
+
+  find(item) {
+    let currNode = this.head;
+    while (currNode.element != item) {
+      currNode = currNode.next;
+    }
+    return currNode;
+  }
+
+  insert(newElement, item){
+    const newNode = new Node(newElement);
+    const current = this.find(item);
+    newNode.next  = current.next;
+    current.next = newNode;
+  }
+
+  findPrevious(item) {
+    let currNode = this.head;
+    while (!(currNode.next === null) && currNode.next.element != item) {
+      currNode = currNode.next;
+    }
+    return currNode;
+  }
+
+  remove(item) {
+    let prevNode = this.findPrevious(item);
+    if(!(prevNode.next === null)) {
+      prevNode.next = prevNode.next.next;
+    }
+  }
+
+  display() {
+    let currNode = this.head;
+    while (!(currNode.next === null)) {
+      console.log(currNode.next.element);
+      currNode = currNode.next;
+    }
+  }
+
+  advance(n) {
+    let position = n;
+    while(!(this.current.next === null)) {
+      if(n-- > 0) {
+        this.current = this.current.next;
+      } else if (this.current.next === null) {
+        console.log(`Can't advanced ${position} position in the list`);
+        break;
+      } else {
+        break;
+      }
+    }
+  }
+
+  show() {
+    console.log(this.current.element);
+  }
+
+}
+
+// Implementation
+// ##########################################
+/*
+  1. Implement the advance(n) function so that when executed, the current node is moved n nodes forward in the list.
+*/
+console.log('CHAPTER 6');
+console.log('### Excercise 1');
+
+const cities = new LList();
+cities.insert("Conway", "Head");
+cities.insert("Russellville", "Conway");
+cities.insert("Carlisle", "Russellville");
+cities.insert("Alma", "Carlisle");
+cities.display();
+console.log('remove; Carlisle\n');
+cities.remove("Carlisle");
+
+console.log('Linked List Elements:');
+cities.display();
+
+console.log('\nAdvance 3 positions');
+cities.advance(3);
+console.log('Display current Node');
+cities.show();

06-chapter-Linked-List/index.js

@@ -0,0 +1,7 @@
+(function (exports) {
+  const {linkedList} = require('./linked-list.module')
+  // const {doubleLinked} = require('./double-linked-list.module')
+  // const {circularLinked} = require('./circular-linked-list.module')
+
+  Object.assign(exports, {linkedList})
+}((typeof module.exports !== 'undefined') ? module.exports : window))

06-chapter-Linked-List/linked-list.module.js

@@ -0,0 +1,91 @@
+(function (exports) {
+  const node = (element = 'Head', next = null) => {
+    const o = {
+      element,
+      next
+    }
+    return Object.assign(Object.create(o), {element, next})
+  }
+
+  const linkedList = (h = null, c = null, l = 0) => {
+    const list = {}
+    let head = h
+    let current = c
+    let length = l
+
+    const findPrevious = (item) => {
+      let currNode = getHead()
+      while (!(currNode.next === null) && currNode.next.element !== item) {
+        currNode = currNode.next
+      }
+      return currNode
+    }
+
+    const getHead = () => head
+
+    list.contains = (item) => {
+      let node = getHead()
+      while (node) {
+        if (node.element === item) {
+          return true
+        }
+        node = node.next
+      }
+      return false
+    }
+
+    list.add = (element) => {
+      const newNode = node(element)
+      if (!head && !current) {
+        head = newNode
+        current = head
+      } else {
+        current.next = newNode
+        current = current.next
+      }
+      length += 1
+    }
+
+    list.remove = (item) => {
+      let prevNode = findPrevious(item)
+      if (!(prevNode.next === null)) {
+        prevNode.next = prevNode.next.next
+        current = prevNode.next
+      }
+      length -= 1
+    }
+
+    list.display = () => {
+      let currNode = head
+      let show = currNode.element + ' -> '
+      while (!(currNode.next === null)) {
+        show += currNode.next.element + ' -> '
+        currNode = currNode.next
+      }
+      show += 'end'
+      console.log(show)
+    }
+
+    list.advance = (n) => {
+      let position = n
+      while (!(current.next === null)) {
+        if (n-- > 0) {
+          current = current.next
+        } else if (current.next === null) {
+          console.log(`Can't advanced ${position} position in the list`)
+          break
+        } else {
+          break
+        }
+      }
+    }
+
+    list.show = () => current.element
+
+    list.size = () => length
+
+    return Object.create(list)
+  }
+
+  Object.assign(exports, {linkedList})
+}((typeof module.exports !== 'undefined') ? module.exports : window))

06-chapter-Linked-List/readme.md

@@ -0,0 +1,31 @@
+# Linked List, Double Linked List, Circular Linked List
+
+### Code Examples
+
+- [Linked List Data Structure]('./linked-list.module')
+- [Double Linked List Data Structure]('./double-linked-list.module')
+- [Circular Linked List Data Structure]('./circular-linked-list.module')
+- [Import complete module]('./index')
+
+### Definition Linked List
+
+The simplest form of linked lists — a singly linked list — is a series of nodes where each individual node contains both a value and a pointer to the next node in the list.
+
+common operations you can perform on graphs:
+
+**Additions**
+- `add`: grow the list by adding items to the end of the list.
+- `addHead`: Similar to our add method above, we always know the position of the head, so no iteration necessary.
+- `insertAfter`: have to iterate over the entire list to find the target node that your value should be inserted after.
+**Removals**
+- `remove`: will always remove from a given position in the list.
+
+**Search**
+- `contains`: will search the list for a value.
+
+### Example use cases
+- Storing values in a hash table to prevent collisions
+
+### Resources
+
+- [A Gentle Introduction to Data Structures: How Linked Lists Work](https://medium.freecodecamp.com/a-gentle-introduction-to-data-structures-how-linked-lists-work-5adc793897dd#.ti1dvnsog)

06-chapter-Linked-List/test.js

@@ -0,0 +1,27 @@
+const {linkedList} = require('./index')
+
+test('Linked List test', assert => {
+  const amazingRace = linkedList()
+
+  amazingRace.add('Colombo, Sri Lanka')
+
+  assert.equal(amazingRace.show(), 'Colombo, Sri Lanka', 'can add an element')
+
+  amazingRace.add('Lagos, Nigeria')
+  amazingRace.add('Surat, India')
+  amazingRace.add('Suzhou, China')
+
+  assert.equal(4, amazingRace.size(), 'can get the size of the linked list')
+  console.log(`contains 'Suzhou, China' ? ${amazingRace.contains('Suzhou, China')}`) // true
+  console.log(`contains 'Hanoi, Vietnam' ? ${amazingRace.contains('Hanoi, Vietnam')}`) // true
+  amazingRace.add('Hanoi, Vietnam')
+  console.log(`contains 'Seattle, Washington' ? ${amazingRace.contains('Seattle, Washington')}`) // true
+  amazingRace.add('Seattle, Washington')
+  console.log(`contains 'North Pole' ? ${amazingRace.contains('North Pole')}`) // true
+  amazingRace.add('North Pole')
+
+  amazingRace.remove('North Pole')
+  amazingRace.remove('Hanoi, Vietnam')
+
+  assert.equal(amazingRace.size(), 5, 'can remove elements')
+})