fix for..of

Author: amejiarosario

.eslintrc.js

@@ -13,6 +13,9 @@ module.exports = {
     // https://eslint.org/docs/rules/no-plusplus
     // allows unary operators ++ and -- in the afterthought (final expression) of a for loop.
     "allowForLoopAfterthoughts": true,
+
+    // Allow for..of
+    "no-restricted-syntax": [0, "ForOfStatement"],
   },
   globals: {
     BigInt: true,

src/data-structures/maps/hash-maps/hashmap.js

@@ -146,7 +146,7 @@ class HashMap {
 
     return !!bucket.remove((node) => {
       if (key === node.value.key) {
-        delete this.keysTrackerArray[node.value.order];
+        delete this.keysTrackerArray[node.value.order]; // O(1) deletion
         this.size -= 1;
         return true;
       }

src/data-structures/maps/tree-maps/tree-map.js

@@ -1,6 +1,7 @@
 /* eslint-disable no-restricted-syntax */
-// const Tree = require('../../trees/red-black-tree'); // fast insertion
-const Tree = require('../../trees/avl-tree'); // fast lookup
+// const Tree = require('../../trees/binary-search-tree'); // unbalanced tree (slow everything)
+// const Tree = require('../../trees/avl-tree'); // fast lookup
+const Tree = require('../../trees/red-black-tree'); // fast insertion
 
 /**
  * TreeMap is a Map implementation using a self-balanced tree

src/data-structures/sets/hash-set.js

@@ -1,14 +1,15 @@
+const HashMap = require('../maps/hash-maps/hashmap');
 /**
- * Set implemented with Map (JS built-in) to have sublinear times on all operations
+ * Set implemented with our HashMap to have sublinear times on all operations
  */
-class HashSet {
+class HashMapSet {
   /**
-   * Initialize Set using the built-in Map
+   * Initialize (Hash)map for the set
    *
    * @param {Array} iterable If passed, all iterable elements will be added to the new Set
    */
   constructor(iterable = []) {
-    this.hashMap = new Map();
+    this.hashMap = new HashMap();
     Array.from(iterable).forEach(element => this.add(element));
   }
 
@@ -54,9 +55,9 @@ class HashSet {
    * Make this class iterable
    */
   [Symbol.iterator]() {
-    return this.hashMap.keys();
+    return this.hashMap.keys()[Symbol.iterator]();
   }
 }
 
-module.exports = HashSet;
+module.exports = HashMapSet;
 

src/data-structures/sets/hash-set-1.js renamed to src/data-structures/sets/map-set.js

@@ -1,15 +1,14 @@
-const HashMap = require('../maps/hash-maps/hashmap');
 /**
- * Set implemented with our HashMap to have sublinear times on all operations
+ * Set implemented with Map (JS built-in) to have sublinear times on all operations
  */
-class HashMapSet {
+class HashSet {
   /**
-   * Initialize (Hash)map for the set
+   * Initialize Set using the built-in Map
    *
    * @param {Array} iterable If passed, all iterable elements will be added to the new Set
    */
   constructor(iterable = []) {
-    this.hashMap = new HashMap();
+    this.hashMap = new Map();
     Array.from(iterable).forEach(element => this.add(element));
   }
 
@@ -55,9 +54,9 @@ class HashMapSet {
    * Make this class iterable
    */
   [Symbol.iterator]() {
-    return this.hashMap.keys()[Symbol.iterator]();
+    return this.hashMap.keys();
   }
 }
 
-module.exports = HashMapSet;
+module.exports = HashSet;
 

src/data-structures/sets/set.spec.js

@@ -1,8 +1,12 @@
 const ArraySet = require('./array-set');
 const HashSet = require('./hash-set');
-const HashMapSet = require('./hash-set-1');
+const MapSet = require('./map-set');
+const TreeSet = require('./tree-set');
 
-[HashSet, HashMapSet, ArraySet].forEach((MySet) => {
+// const setImplementations = [HashSet, MapSet, ArraySet, TreeSet, Set];
+const setImplementations = [Set, HashSet, TreeSet];
+
+setImplementations.forEach((MySet) => {
   describe(`Set (${MySet.name})`, () => {
     let set;
 
@@ -43,7 +47,7 @@ const HashMapSet = require('./hash-set-1');
       set.add(1);
       set.add(2);
       set.add(3);
-      expect(set.entries()).toEqual([1, 2, 3]);
+      expect([...set.entries()]).toEqual([[1, 1], [2, 2], [3, 3]]);
     });
 
     it('should return entries wihout holes', () => {
@@ -53,17 +57,17 @@ const HashMapSet = require('./hash-set-1');
       set.add(3);
 
       expect(set.delete(2)).toBe(true);
-      expect(set.entries()).toEqual([0, 1, 3]);
+      expect(Array.from(set.entries())).toEqual([[0, 0], [1, 1], [3, 3]]);
       expect(set.delete(0)).toBe(true);
 
-      expect(set.entries()).toEqual([1, 3]);
+      expect(Array.from(set)).toEqual([1, 3]);
       expect(set.size).toBe(2);
     });
 
     it('should initialize with data provided', () => {
       set = new MySet([1, 2, 3, 1]);
       expect(set.size).toBe(3);
-      expect(set.entries()).toEqual([1, 2, 3]);
+      expect(Array.from(set.keys())).toEqual([1, 2, 3]);
     });
 
     it('should return an iterable', () => {

src/data-structures/sets/tree-set.js

@@ -0,0 +1,54 @@
+// const Tree = require('../trees/avl-tree');
+const Tree = require('../trees/red-black-tree');
+
+class TreeSet {
+  constructor(iterable = []) {
+    this.tree = new Tree();
+    Array.from(iterable).forEach(value => this.add(value));
+  }
+
+  get size() {
+    return this.tree.size;
+  }
+
+  add(value) {
+    if (!this.has(value)) {
+      this.tree.add(value);
+    }
+  }
+
+  has(value) {
+    return !!this.tree.get(value);
+  }
+
+  delete(value) {
+    return this.tree.remove(value);
+  }
+
+  * keys() {
+    for (const node of this.tree.inOrderTraversal()) {
+      yield node.value;
+    }
+  }
+
+  /**
+   * Default iterator for this set
+   */
+  * [Symbol.iterator]() {
+    yield* this.keys();
+  }
+
+  /**
+   * This is kept similar to the Map object, so that each entry has the
+   *  same value for its key and value here.
+   * @returns {iterator} new Iterator object that contains[value, value]
+   *  for each element in the Set object, in ascending order.
+   */
+  * entries() {
+    for (const value of this) {
+      yield [value, value];
+    }
+  }
+}
+
+module.exports = TreeSet;