Merge branch 'master' into lru-cache

README.md

@@ -21,6 +21,7 @@ Light weight javascript data structures library
 - Graph
 - Disjoint-set
 - LRU Cache (New!)
+- HashSet
 
 ## Installation and Usage
 
@@ -143,6 +144,22 @@ lru.get(4)   // 4
 
 ```
 
+### Hash-set
+
+```js
+const { HashSet } = require("data-structures-again");
+
+const set = new HashSet()
+set.add(1)
+set.add(2)
+
+set.has(1) // true
+set.has(2) // true
+set.has(3)) // false
+
+```
+
+
 ## License
 
 MIT.

index.js

@@ -5,6 +5,8 @@ const Heap = require('./src/heap')
 const Graph = require('./src/graph')
 const DisjointSet = require('./src/disjoint-set')
 const LRUCache = require('./src/lru-cache')
+const HashSet = require('./src/hash-set')
+
 
 module.exports = {
     BST,
@@ -13,5 +15,6 @@ module.exports = {
     Heap,
     Graph,
     DisjointSet,
-    LRUCache
+    LRUCache,
+    HashSet
 }

index.test.js

@@ -72,6 +72,7 @@ test('disjoint-set example', () => {
     expect(ds.isConnected('a', 'd')).toBeTruthy()
 })
 
+
 test('LRU Cache example', () => {
     const { LRUCache } = require('./index')
 
@@ -87,3 +88,16 @@ test('LRU Cache example', () => {
     lru.get(3) // 3
     lru.get(4) // 4
 })
+
+test('hash-set example', () => {
+    const { HashSet } = require('./index')
+
+    const set = new HashSet()
+    set.add(1)
+    set.add(2)
+
+    expect(set.has(1)).toBeTruthy() // true
+    expect(set.has(2)).toBeTruthy()
+    expect(set.has(3)).toBeFalsy()
+
+})

package.json

@@ -1,14 +1,14 @@
 {
   "name": "data-structures-again",
-  "version": "2.1.2",
+  "version": "2.1.10",
   "description": "A Javascript library of simple data structures",
   "homepage": "https://github.com/divyanshyadav/data-structures-again",
   "main": "index.js",
   "scripts": {
     "lint": "eslint src",
     "lint:fix": "eslint src --fix",
     "test": "jest",
-    "test:watch": "jest --watchAll",
+    "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
     "test:coveralls": "jest --coverage && cat coverage/lcov.info | node ./node_modules/coveralls/bin/coveralls.js",
     "build": "webpack",

src/disjoint-set/index.js

@@ -32,7 +32,8 @@ class DisjointSet {
 
         if (this.rank[parentOfB] > this.rank[parentOfA]) {
             this.container[parentOfA] = parentOfB
-            this.rank[parentOfB] += 1
+        } else if (this.rank[parentOfA] > this.rank[parentOfB]) {
+            this.container[parentOfB] = parentOfA
         } else {
             this.container[parentOfB] = parentOfA
             this.rank[parentOfA] += 1

src/graph/index.js

@@ -25,7 +25,7 @@ class Vertex {
     }
 
     getAdjVertices () {
-        return this.adjVertices.toArray().map(n => n.name)
+        return this.adjVertices.toArray()
     }
 
     hasAdjVertex (name) {
@@ -70,8 +70,13 @@ class Graph {
             .addNeighbor(this.getVertex(v2).name, weight)
     }
 
+    addUndirectedEdge (v1, v2, weight) {
+        this.addEdge(v1, v2, weight)
+        this.addEdge(v2, v1, weight)
+    }
+
     getAdjVertices (vertex) {
-        return this.getVertex(vertex).adjVertices
+        return this.getVertex(vertex).getAdjVertices()
     }
 
     isAdjacent (v1, v2) {
@@ -132,7 +137,7 @@ class Graph {
             const current = queue.dequeue()
 
             current.getAdjVertices().forEach(v => {
-                const neighbor = this.getVertex(v)
+                const neighbor = this.getVertex(v.name)
 
                 if (neighbor.color === COLORS.white) {
                     neighbor.color = COLORS.grey
@@ -157,7 +162,7 @@ class Graph {
             fn(vertex)
 
             vertex.getAdjVertices().forEach(v => {
-                const neighbor = this.getVertex(v)
+                const neighbor = this.getVertex(v.name)
                 if (neighbor.color === COLORS.white) {
                     helper(neighbor)
                 }
@@ -168,6 +173,30 @@ class Graph {
 
         helper(startVertex)
     }
+    /**
+     * @returns {[[String, String, Number]]}
+     */
+    getEdges () {
+        const edges = []
+        for (const [vertex, value] of this.adjList) {
+            const neighbors = value.getAdjVertices()
+            neighbors.forEach(n => {
+                edges.push([vertex, n.name, this.getEdgeValue(vertex, n.name)])
+            })
+        };
+
+        return edges
+    }
+
+    getVertices () {
+        const vertices = []
+        // eslint-disable-next-line no-unused-vars
+        for (const [_, value] of this.adjList) {
+            vertices.push(value)
+        }
+
+        return vertices
+    }
 }
 
 module.exports = Graph

src/graph/index.test.js

@@ -24,8 +24,8 @@ describe('test graph DS', () => {
         graph.addEdge('c', 'a')
         graph.addEdge('c', 'b')
 
-        expect(graph.getAdjVertices('a').toArray().map(e => e.name)).toEqual(['b'])
-        expect(graph.getAdjVertices('c').toArray().map(e => e.name)).toEqual(['a', 'b'])
+        expect(graph.getAdjVertices('a').map(e => e.name)).toEqual(['b'])
+        expect(graph.getAdjVertices('c').map(e => e.name)).toEqual(['a', 'b'])
     })
 
     it('should do bfs', () => {
@@ -220,4 +220,67 @@ describe('test graph DS', () => {
         const graph = new Graph()
         expect(() => graph.dfs('a')).toThrow()
     })
+
+    it('should return all edges', () => {
+        const graph = new Graph()
+
+        /*
+            a---> b
+            ^    /
+            |   /
+              c
+        */
+
+        graph.addVertex('a')
+        graph.addVertex('b')
+        graph.addVertex('c')
+
+        graph.addEdge('a', 'b')
+        graph.addEdge('c', 'a')
+        graph.addEdge('c', 'b')
+
+        expect(graph.getEdges()).toEqual(
+            [['a', 'b', 0], ['c', 'a', 0], ['c', 'b', 0]]
+        )
+    })
+
+    it('should return all vertices', () => {
+        const graph = new Graph()
+
+        /*
+            a---> b
+            ^    /
+            |   /
+              c
+        */
+
+        graph.addVertex('a')
+        graph.addVertex('b')
+        graph.addVertex('c')
+
+        expect(graph.getVertices().map(v => v.name)).toEqual(['a', 'b', 'c'])
+    })
+
+    it('should construct a undirected graph', () => {
+        const graph = new Graph()
+
+        /*
+            a--- b
+            |    /
+            |   /
+            c /
+        */
+
+        graph.addVertex('a')
+        graph.addVertex('b')
+        graph.addVertex('c')
+
+        graph.addUndirectedEdge('a', 'b')
+        graph.addUndirectedEdge('c', 'a')
+        graph.addUndirectedEdge('c', 'b')
+
+        expect(graph.getAdjVertices('a').map(e => e.name)).toEqual(['b', 'c'])
+        expect(graph.getAdjVertices('b').map(e => e.name)).toEqual(['a', 'c'])
+        expect(graph.getAdjVertices('c').map(e => e.name)).toEqual(['a', 'b'])
+    })
 })