Trie (#8)

* Added trie

* Added hasWord

* Added find

Author: jasonheecs

package-lock.json

@@ -5,6 +5,7 @@
   "main": "lib/index.js",
   "scripts": {
     "lint": "eslint src/*.js test/*.js",
+    "fix-lint": "eslint src/*.js test/*.js --fix",
     "prepare": "./node_modules/babel-cli/bin/babel.js src --out-dir lib",
     "precommit": "npm run lint",
     "test": "nyc --reporter=html --reporter=text mocha --require babel-core/register",
@@ -43,6 +44,7 @@
     "eslint-plugin-standard": "^3.0.1",
     "husky": "^0.14.3",
     "mocha": "^5.1.1",
-    "nyc": "^11.7.1"
+    "nyc": "^11.7.1",
+    "random-words": "^1.1.0"
   }
 }

package.json

@@ -6,12 +6,14 @@ import CircularList from './circular-linked-list.js';
 import Stack from './stack.js';
 import Queue from './queue.js';
 import BST from './binary-search-tree.js';
+import Trie from './trie.js';
 
 export {
   List,
   DoublyList,
   CircularList,
   Stack,
   Queue,
-  BST
+  BST,
+  Trie
 };

src/index.js

@@ -0,0 +1,121 @@
+'use strict';
+
+class Node {
+  constructor (value = null, isCompleteWord = false) {
+    this.value = value;
+    this.children = new Map();
+    this.isCompleteWord = isCompleteWord;
+  }
+
+  /**
+   * @param {char} value
+   * @param {Node} node
+   */
+  setChild (value, node) {
+    this.children.set(value, node);
+  }
+
+  /**
+   * @param  {char} value
+   * @return {Node}
+   */
+  getChild (value) {
+    return this.children.get(value);
+  }
+}
+
+export default class Trie {
+  constructor () {
+    this.root = new Node();
+  }
+
+  /**
+  * @param {string} word
+  */
+  addWord (word) {
+    if (!this.isValidWord(word)) {
+      throw Error('Invalid Word');
+    }
+
+    let current = this.root;
+
+    Array.from(word).forEach((letter) => {
+      if (!current.getChild(letter)) {
+        current.setChild(letter, new Node(letter));
+      }
+
+      current = current.getChild(letter);
+    });
+
+    current.isCompleteWord = true;
+  }
+
+  /**
+  * @return {Array<string>}
+  */
+  getWords () {
+    let words = [];
+
+    const getWords = (node, wordFragment) => {
+      node.children.forEach((child) => {
+        if (child.isCompleteWord) {
+          words.push(wordFragment + child.value);
+        }
+
+        getWords(child, wordFragment + child.value);
+      });
+    };
+
+    getWords(this.root, '');
+
+    return words;
+  }
+
+  /**
+   * @param  {string}  word
+   * @return {Boolean}
+   */
+  hasWord (word) {
+    let current = this.root;
+
+    Array.from(word).forEach((letter) => {
+      if (!current.getChild(letter)) {
+        return false;
+      }
+
+      current = current.getChild(letter);
+    });
+
+    return current.isCompleteWord;
+  }
+
+  /**
+   * @param  {string} prefix
+   * @return {Node}
+   */
+  find (prefix) {
+    if (!this.isValidWord(prefix)) {
+      throw Error('Invalid Word');
+    }
+
+    let current = this.root;
+
+    Array.from(prefix).forEach((letter) => {
+      if (!current.getChild(letter)) {
+        return null;
+      }
+
+      current = current.getChild(letter);
+    });
+
+    return current.value === null ? null : current;
+  }
+
+  /**
+  * @param  {string}  word
+  * @return {Boolean}
+  */
+  isValidWord (word) {
+    return (typeof (word) === 'string' || word instanceof String) && word.match(/^[A-z]+$/);
+  }
+}

src/trie.js

@@ -0,0 +1,72 @@
+'use strict';
+
+import {Trie} from '../src/index.js';
+
+const randomWords = require('random-words');
+const expect = require('chai').expect;
+
+/**
+ * @param  {Array<string>} words
+ * @return {Trie}
+ */
+function createTrie (words) {
+  let trie = new Trie();
+
+  words.forEach((word) => {
+    trie.addWord(word);
+  });
+
+  return trie;
+}
+
+describe('testing trie', function () {
+  it('test adding values', function () {
+    let words = randomWords(50);
+    let trie = createTrie(words);
+
+    expect(trie.getWords()).to.include.members(words);
+  });
+
+  it('test adding invalid values', function () {
+    let trie = new Trie();
+
+    let invalidInputs = ['', 123, '$%^&', '123'];
+
+    invalidInputs.forEach((input) => {
+      expect(trie.addWord.bind(trie, input)).to.throw(Error, 'Invalid Word');
+    });
+  });
+
+  it('test checking if word exists', function () {
+    let words = randomWords(50);
+    let trie = createTrie(words);
+
+    words.forEach((word) => {
+      expect(trie.hasWord(word)).to.be.true;
+    });
+  });
+
+  it('test checking if word does not exist', function () {
+    let words = ['call', 'dog', 'carded'];
+    let trie = createTrie(words);
+
+    expect(trie.hasWord('cat')).to.be.false;
+    expect(trie.hasWord('card')).to.be.false;
+  });
+
+  it('test hasWord for empty trie', function () {
+    let trie = new Trie();
+
+    expect(trie.hasWord('cat')).to.be.false;
+  });
+
+  it('test finding node based on prefix', function () {
+    let words = ['call', 'dog', 'carded'];
+    let trie = createTrie(words);
+
+    expect(trie.find('ca').children.size).to.be.above(1);
+    expect(trie.find('do').children.size).to.equal(1);
+    expect(trie.find('o')).to.equal(null);
+    expect(trie.find.bind(trie, '')).to.throw(Error, 'Invalid Word');
+  });
+});