Merge branch 'master' into master

Author: trekhleb

README.md

@@ -49,6 +49,8 @@ be accessed and modified efficiently. More precisely, a data structure is a coll
 values, the relationships among them, and the functions or operations that can be applied to
 the data.
 
+Remember that each data has its own trade-offs. And you need to pay attention more to why you're choosing a certain data structure than to how to implement it.
+
 `B` - Beginner, `A` - Advanced
 
 * `B` [Linked List](src/data-structures/linked-list)

src/algorithms/search/binary-search/binarySearch.js

@@ -11,7 +11,7 @@ import Comparator from '../../../utils/comparator/Comparator';
 
 export default function binarySearch(sortedArray, seekElement, comparatorCallback) {
   // Let's create comparator from the comparatorCallback function.
-  // Comparator object will give us common comparison methods like equal() and lessThen().
+  // Comparator object will give us common comparison methods like equal() and lessThan().
   const comparator = new Comparator(comparatorCallback);
 
   // These two indices will contain current array (sub-array) boundaries.

src/algorithms/uncategorized/best-time-to-buy-sell-stocks/README.md

@@ -46,7 +46,7 @@ Let's say we have an array of prices `[7, 6, 4, 3, 1]` and we're on the _1st_ da
 1. _Option 1: Keep the money_ → profit would equal to the profit from buying/selling the rest of the stocks → `keepProfit = profit([6, 4, 3, 1])`.
 2. _Option 2: Buy/sell at current price_ → profit in this case would equal to the profit from buying/selling the rest of the stocks plus (or minus, depending on whether we're selling or buying) the current stock price → `buySellProfit = -7 + profit([6, 4, 3, 1])`.
 
-The overall profit would be equal to → `overalProfit = Max(keepProfit, buySellProfit)`.
+The overall profit would be equal to → `overallProfit = Max(keepProfit, buySellProfit)`.
 
 As you can see the `profit([6, 4, 3, 1])` task is being solved in the same recursive manner.
 

src/algorithms/uncategorized/n-queens/README.md

@@ -59,7 +59,7 @@ and return false.
         queen here leads to a solution.
     b) If placing queen in [row, column] leads to a solution then return 
         true.
-    c) If placing queen doesn't lead to a solution then umark this [row, 
+    c) If placing queen doesn't lead to a solution then unmark this [row, 
         column] (Backtrack) and go to step (a) to try other rows.
 3) If all rows have been tried and nothing worked, return false to trigger 
     backtracking.

src/data-structures/bloom-filter/README.md

@@ -93,7 +93,7 @@ three factors: the size of the bloom filter, the
 number of hash functions we use, and the number
 of items that have been inserted into the filter.
 
-The formula to calculate probablity of a false positive is:
+The formula to calculate probability of a false positive is:
 
 ( 1 - e <sup>-kn/m</sup> ) <sup>k</sup>
 

src/data-structures/disjoint-set/DisjointSetAdhoc.js

@@ -0,0 +1,78 @@
+/**
+ * The minimalistic (ad hoc) version of a DisjointSet (or a UnionFind) data structure
+ * that doesn't have external dependencies and that is easy to copy-paste and
+ * use during the coding interview if allowed by the interviewer (since many
+ * data structures in JS are missing).
+ *
+ * Time Complexity:
+ *
+ * - Constructor: O(N)
+ * - Find: O(α(N))
+ * - Union: O(α(N))
+ * - Connected: O(α(N))
+ *
+ * Where N is the number of vertices in the graph.
+ * α refers to the Inverse Ackermann function.
+ * In practice, we assume it's a constant.
+ * In other words, O(α(N)) is regarded as O(1) on average.
+ */
+class DisjointSetAdhoc {
+  /**
+   * Initializes the set of specified size.
+   * @param {number} size
+   */
+  constructor(size) {
+    // The index of a cell is an id of the node in a set.
+    // The value of a cell is an id (index) of the root node.
+    // By default, the node is a parent of itself.
+    this.roots = new Array(size).fill(0).map((_, i) => i);
+
+    // Using the heights array to record the height of each node.
+    // By default each node has a height of 1 because it has no children.
+    this.heights = new Array(size).fill(1);
+  }
+
+  /**
+   * Finds the root of node `a`
+   * @param {number} a
+   * @returns {number}
+   */
+  find(a) {
+    if (a === this.roots[a]) return a;
+    this.roots[a] = this.find(this.roots[a]);
+    return this.roots[a];
+  }
+
+  /**
+   * Joins the `a` and `b` nodes into same set.
+   * @param {number} a
+   * @param {number} b
+   * @returns {number}
+   */
+  union(a, b) {
+    const aRoot = this.find(a);
+    const bRoot = this.find(b);
+
+    if (aRoot === bRoot) return;
+
+    if (this.heights[aRoot] > this.heights[bRoot]) {
+      this.roots[bRoot] = aRoot;
+    } else if (this.heights[aRoot] < this.heights[bRoot]) {
+      this.roots[aRoot] = bRoot;
+    } else {
+      this.roots[bRoot] = aRoot;
+      this.heights[aRoot] += 1;
+    }
+  }
+
+  /**
+   * Checks if `a` and `b` belong to the same set.
+   * @param {number} a
+   * @param {number} b
+   */
+  connected(a, b) {
+    return this.find(a) === this.find(b);
+  }
+}
+
+export default DisjointSetAdhoc;

src/data-structures/disjoint-set/README.md

@@ -19,6 +19,11 @@ _MakeSet_ creates 8 singletons.
 
 After some operations of _Union_, some sets are grouped together.
 
+## Implementation
+
+- [DisjointSet.js](./DisjointSet.js)
+- [DisjointSetAdhoc.js](./DisjointSetAdhoc.js) - The minimalistic (ad hoc) version of a DisjointSet (or a UnionFind) data structure that doesn't have external dependencies and that is easy to copy-paste and use during the coding interview if allowed by the interviewer (since many data structures in JS are missing).
+
 ## References
 
 - [Wikipedia](https://en.wikipedia.org/wiki/Disjoint-set_data_structure)

src/data-structures/disjoint-set/__test__/DisjointSetAdhoc.test.js

@@ -0,0 +1,50 @@
+import DisjointSetAdhoc from '../DisjointSetAdhoc';
+
+describe('DisjointSetAdhoc', () => {
+  it('should create unions and find connected elements', () => {
+    const set = new DisjointSetAdhoc(10);
+
+    // 1-2-5-6-7 3-8-9 4
+    set.union(1, 2);
+    set.union(2, 5);
+    set.union(5, 6);
+    set.union(6, 7);
+
+    set.union(3, 8);
+    set.union(8, 9);
+
+    expect(set.connected(1, 5)).toBe(true);
+    expect(set.connected(5, 7)).toBe(true);
+    expect(set.connected(3, 8)).toBe(true);
+
+    expect(set.connected(4, 9)).toBe(false);
+    expect(set.connected(4, 7)).toBe(false);
+
+    // 1-2-5-6-7 3-8-9-4
+    set.union(9, 4);
+
+    expect(set.connected(4, 9)).toBe(true);
+    expect(set.connected(4, 3)).toBe(true);
+    expect(set.connected(8, 4)).toBe(true);
+
+    expect(set.connected(8, 7)).toBe(false);
+    expect(set.connected(2, 3)).toBe(false);
+  });
+
+  it('should keep the height of the tree small', () => {
+    const set = new DisjointSetAdhoc(10);
+
+    // 1-2-6-7-9 1 3 4 5
+    set.union(7, 6);
+    set.union(1, 2);
+    set.union(2, 6);
+    set.union(1, 7);
+    set.union(9, 1);
+
+    expect(set.connected(1, 7)).toBe(true);
+    expect(set.connected(6, 9)).toBe(true);
+    expect(set.connected(4, 9)).toBe(false);
+
+    expect(Math.max(...set.heights)).toBe(3);
+  });
+});

src/data-structures/heap/Heap.js

@@ -279,7 +279,7 @@ export default class Heap {
   /* istanbul ignore next */
   pairIsInCorrectOrder(firstElement, secondElement) {
     throw new Error(`
-      You have to implement heap pair comparision method
+      You have to implement heap pair comparison method
       for ${firstElement} and ${secondElement} values.
     `);
   }

src/data-structures/heap/MaxHeapAdhoc.js

@@ -0,0 +1,115 @@
+/**
+ * The minimalistic (ad hoc) version of a MaxHeap data structure that doesn't have
+ * external dependencies and that is easy to copy-paste and use during the
+ * coding interview if allowed by the interviewer (since many data
+ * structures in JS are missing).
+ */
+class MaxHeapAdhoc {
+  constructor(heap = []) {
+    this.heap = [];
+    heap.forEach(this.add);
+  }
+
+  add(num) {
+    this.heap.push(num);
+    this.heapifyUp();
+  }
+
+  peek() {
+    return this.heap[0];
+  }
+
+  poll() {
+    if (this.heap.length === 0) return undefined;
+    const top = this.heap[0];
+    this.heap[0] = this.heap[this.heap.length - 1];
+    this.heap.pop();
+    this.heapifyDown();
+    return top;
+  }
+
+  isEmpty() {
+    return this.heap.length === 0;
+  }
+
+  toString() {
+    return this.heap.join(',');
+  }
+
+  heapifyUp() {
+    let nodeIndex = this.heap.length - 1;
+    while (nodeIndex > 0) {
+      const parentIndex = this.getParentIndex(nodeIndex);
+      if (this.heap[parentIndex] >= this.heap[nodeIndex]) break;
+      this.swap(parentIndex, nodeIndex);
+      nodeIndex = parentIndex;
+    }
+  }
+
+  heapifyDown() {
+    let nodeIndex = 0;
+
+    while (
+      (
+        this.hasLeftChild(nodeIndex) && this.heap[nodeIndex] < this.leftChild(nodeIndex)
+      )
+      || (
+        this.hasRightChild(nodeIndex) && this.heap[nodeIndex] < this.rightChild(nodeIndex)
+      )
+    ) {
+      const leftIndex = this.getLeftChildIndex(nodeIndex);
+      const rightIndex = this.getRightChildIndex(nodeIndex);
+      const left = this.leftChild(nodeIndex);
+      const right = this.rightChild(nodeIndex);
+
+      if (this.hasLeftChild(nodeIndex) && this.hasRightChild(nodeIndex)) {
+        if (left >= right) {
+          this.swap(leftIndex, nodeIndex);
+          nodeIndex = leftIndex;
+        } else {
+          this.swap(rightIndex, nodeIndex);
+          nodeIndex = rightIndex;
+        }
+      } else if (this.hasLeftChild(nodeIndex)) {
+        this.swap(leftIndex, nodeIndex);
+        nodeIndex = leftIndex;
+      }
+    }
+  }
+
+  getLeftChildIndex(parentIndex) {
+    return (2 * parentIndex) + 1;
+  }
+
+  getRightChildIndex(parentIndex) {
+    return (2 * parentIndex) + 2;
+  }
+
+  getParentIndex(childIndex) {
+    return Math.floor((childIndex - 1) / 2);
+  }
+
+  hasLeftChild(parentIndex) {
+    return this.getLeftChildIndex(parentIndex) < this.heap.length;
+  }
+
+  hasRightChild(parentIndex) {
+    return this.getRightChildIndex(parentIndex) < this.heap.length;
+  }
+
+  leftChild(parentIndex) {
+    return this.heap[this.getLeftChildIndex(parentIndex)];
+  }
+
+  rightChild(parentIndex) {
+    return this.heap[this.getRightChildIndex(parentIndex)];
+  }
+
+  swap(indexOne, indexTwo) {
+    const tmp = this.heap[indexTwo];
+    this.heap[indexTwo] = this.heap[indexOne];
+    this.heap[indexOne] = tmp;
+  }
+}
+
+export default MaxHeapAdhoc;