chapter 05: [LinkedLists]

Author: loiane

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "typescript.tsdk": "node_modules/typescript/lib"
+}

README.md

@@ -14,6 +14,7 @@ Work in Progress.
 * 02: [Arrays](https://github.com/loiane/javascript-datastructures-algorithms/tree/third-edition/examples/chapter02)
 * 03: [Stacks](https://github.com/loiane/javascript-datastructures-algorithms/tree/third-edition/examples/chapter03)
 * 04: [Queues and Deques](https://github.com/loiane/javascript-datastructures-algorithms/tree/third-edition/examples/chapter04)
+* 05: [LinkedLists](https://github.com/loiane/javascript-datastructures-algorithms/tree/third-edition/examples/chapter05)
 
 ## Thrid Edition Updates
 

examples/PacktDataStructuresAlgorithms.min.js

@@ -55,24 +55,24 @@
     "@types/mocha": "^2.2.42",
     "babel-cli": "^6.26.0",
     "babel-core": "^6.26.0",
-    "babel-eslint": "^8.0.0",
+    "babel-eslint": "^8.0.1",
     "babel-loader": "^7.1.2",
     "babel-plugin-add-module-exports": "^0.2.1",
     "babel-plugin-transform-es2015-modules-umd": "^6.24.1",
     "babel-preset-env": "^1.6.0",
     "chai": "^4.1.2",
     "codecov": "^2.3.0",
-    "eslint": "^4.6.1",
-    "eslint-config-airbnb-base": "^12.0.0",
+    "eslint": "^4.8.0",
+    "eslint-config-airbnb-base": "^12.0.2",
     "eslint-plugin-import": "^2.7.0",
     "istanbul": "^v1.1.0-alpha.1",
-    "mocha": "^3.5.0",
+    "mocha": "^4.0.1",
     "mochawesome": "^2.3.1",
     "nyc": "^11.2.1",
     "ts-node": "^3.3.0",
     "tslint": "^5.7.0",
-    "typescript": "^2.5.2",
-    "webpack": "^3.6.0",
+    "typescript": "^2.6.0-dev.20171014",
+    "webpack": "^3.7.1",
     "yargs": "^9.0.1"
   }
 }

package.json

@@ -0,0 +1,166 @@
+import { defaultEquals, IEqualsFunction } from '../util';
+import { Node } from './models/linked-list-models';
+
+export default class CircularLinkedList<T> {
+  private count = 0;
+  private head: Node<T> | undefined;
+
+  constructor(private equalsFn: IEqualsFunction<T> =  defaultEquals) { }
+
+  private getLastElement() {
+    let current = this.head;
+    for (let i = 2; i <= this.size() && current; i++) {
+      current = current.next;
+    }
+    return current;
+  }
+
+  push(element: T) {
+    const node = new Node(element);
+    let current;
+
+    if (this.head === undefined || this.head === null) {
+      this.head = node;
+    } else {
+      current = this.getLastElement();
+      if (current) {
+        current.next = node;
+      }
+    }
+
+    // set node.next to head - to have circular list
+    node.next = this.head;
+
+    this.count++;
+  }
+
+  getElementAt(index: number) {
+    if (index >= 0 && index <= this.count) {
+      let node = this.head;
+      for (let i = 0; i < index; i++) {
+        if (node) {
+          node = node.next;
+        }
+      }
+      return node;
+    }
+    return undefined;
+  }
+
+  insert(index: number, element: T) {
+    if (index >= 0 && index <= this.count) {
+      const node = new Node(element);
+      let current = this.head;
+
+      if (index === 0) {
+        if (!this.head) {
+          // if no node  in list
+          this.head = node;
+          node.next = this.head;
+        } else {
+          node.next = current;
+          current = this.getLastElement();
+          // update last element
+          this.head = node;
+          if (current) {
+            current.next = this.head;
+          }
+        }
+      } else {
+        const previous = this.getElementAt(index - 1);
+        if (previous) {
+          node.next = previous.next;
+          previous.next = node;
+        }
+      }
+      this.count++;
+      return true;
+    }
+    return false;
+  }
+
+  removeAt(index: number) {
+    if (index >= 0 && index < this.count) {
+      let current = this.head;
+
+      if (index === 0) {
+        const removed = this.head;
+
+        if (this.size() === 1) {
+          this.head = undefined;
+        } else {
+          current = this.getLastElement();
+          if (this.head) {
+            this.head = this.head.next;
+          }
+          if (current) {
+            current.next = this.head;
+          }
+          current = removed;
+        }
+      } else {
+        // no need to update last element for circular list
+        const previous = this.getElementAt(index - 1);
+        if (previous) {
+          current = previous.next;
+          if (current) {
+            previous.next = current.next;
+          }
+        }
+      }
+      if (current) {
+        this.count--;
+        return current.element;
+      }
+    }
+    return undefined;
+  }
+
+  remove(element: T) {
+    const index = this.indexOf(element);
+    return this.removeAt(index);
+  }
+
+  indexOf(element: T) {
+    let current = this.head;
+
+    for (let i = 1; i <= this.size() && current; i++) {
+      if (this.equalsFn(element, current.element)) {
+        return i - 1;
+      }
+      current = current.next;
+    }
+
+    return -1;
+  }
+
+  isEmpty() {
+    return this.size() === 0;
+  }
+
+  size() {
+    return this.count;
+  }
+
+  getHead() {
+    return this.head;
+  }
+
+  clear() {
+    this.head = undefined;
+    this.count = 0;
+  }
+
+  toString() {
+    if (this.head === undefined) {
+      return '';
+    }
+    let objString = `${this.head.element}`;
+    let current = this.head.next;
+    for (let i = 2; i <= this.size() && current; i++) {
+      objString = `${objString},${current.element}`;
+      current = current.next;
+    }
+    return objString;
+  }
+}