Merge pull request #3 from trekhleb/master

Added Binary Indexed Tree / Fenwick Tree Implementation

Author: aalhour

README.md

@@ -33,6 +33,7 @@ the data.
     * [AVL Tree](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/tree/avl-tree)
     * [Red-Black Tree](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/tree/red-black-tree)
     * [Segment Tree](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/tree/segment-tree) - with min/max/sum range queries examples
+    * [Fenwick Tree](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/tree/fenwick-tree) (Binary Indexed Tree)
 * [Graph](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/graph) (both directed and undirected)
 * [Disjoint Set](https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/disjoint-set)
 

README.zh-TW.md

@@ -197,7 +197,7 @@ npm test -- -t 'playground'
 | **紅黑樹**              | log(n)    | log(n)    | log(n)    | log(n)    |
 | **AVL Tree**            | log(n)    | log(n)    | log(n)    | log(n)    |
 
-### 陣列搜尋演算法複雜度
+### 陣列排序演算法複雜度
 
 | 名稱                   | 最佳      | 平均      | 最差           | 記憶體    | 穩定      |
 | --------------------- | :-------: | :-------: | :-----------: | :-------: | :-------: |

src/algorithms/math/primality-test/README.md

@@ -1,6 +1,16 @@
 # Primality Test
 
-A primality test is an algorithm for determining whether an input 
+A **prime number** (or a **prime**) is a natural number greater than `1` that 
+cannot be formed by multiplying two smaller natural numbers. A natural number 
+greater than `1` that is not prime is called a composite number. For 
+example, `5` is prime because the only ways of writing it as a 
+product, `1 × 5` or `5 × 1`, involve `5` itself. However, `6` is 
+composite because it is the product of two numbers `(2 × 3)` that are 
+both smaller than `6`. 
+
+![Prime Numbers](https://upload.wikimedia.org/wikipedia/commons/f/f0/Primes-vs-composites.svg)
+
+A **primality test** is an algorithm for determining whether an input 
 number is prime. Among other fields of mathematics, it is used 
 for cryptography. Unlike integer factorization, primality tests 
 do not generally give prime factors, only stating whether the 
@@ -11,4 +21,5 @@ size of the input).
 
 ## References
 
-[Wikipedia](https://en.wikipedia.org/wiki/Primality_test)
+- [Prime Numbers on Wikipedia](https://en.wikipedia.org/wiki/Prime_number)
+- [Primality Test on Wikipedia](https://en.wikipedia.org/wiki/Primality_test)

src/algorithms/math/primality-test/__test__/trialDivision.test.js

@@ -23,6 +23,11 @@ function primalityTest(testFunction) {
   expect(testFunction(192)).toBeFalsy();
   expect(testFunction(200)).toBeFalsy();
   expect(testFunction(400)).toBeFalsy();
+
+  // It should also deal with floats.
+  expect(testFunction(0.5)).toBeFalsy();
+  expect(testFunction(1.3)).toBeFalsy();
+  expect(testFunction(10.5)).toBeFalsy();
 }
 
 describe('trialDivision', () => {

src/algorithms/math/primality-test/trialDivision.js

@@ -3,6 +3,11 @@
  * @return {boolean}
  */
 export default function trialDivision(number) {
+  // Check if number is integer.
+  if (number % 1 !== 0) {
+    return false;
+  }
+
   if (number <= 1) {
     // If number is less than one then it isn't prime by definition.
     return false;

src/data-structures/heap/MinHeap.js

@@ -141,8 +141,8 @@ export default class MinHeap {
    */
   remove(item, customFindingComparator) {
     // Find number of items to remove.
-    const numberOfItemsToRemove = this.find(item).length;
     const customComparator = customFindingComparator || this.compare;
+    const numberOfItemsToRemove = this.find(item, customComparator).length;
 
     for (let iteration = 0; iteration < numberOfItemsToRemove; iteration += 1) {
       // We need to find item index to remove each time after removal since

src/data-structures/heap/__test__/MinHeap.test.js

@@ -1,4 +1,5 @@
 import MinHeap from '../MinHeap';
+import Comparator from '../../../utils/comparator/Comparator';
 
 describe('MinHeap', () => {
   it('should create an empty min heap', () => {
@@ -147,4 +148,25 @@ describe('MinHeap', () => {
     expect(minHeap.remove(3).toString()).toEqual('4');
     expect(minHeap.remove(4).toString()).toEqual('');
   });
+
+  it('should be possible to remove items from heap with custom finding comparator', () => {
+    const minHeap = new MinHeap();
+    minHeap.add('dddd');
+    minHeap.add('ccc');
+    minHeap.add('bb');
+    minHeap.add('a');
+
+    expect(minHeap.toString()).toBe('a,bb,ccc,dddd');
+
+    const comparator = new Comparator((a, b) => {
+      if (a.length === b.length) {
+        return 0;
+      }
+
+      return a.length < b.length ? -1 : 1;
+    });
+
+    minHeap.remove('hey', comparator);
+    expect(minHeap.toString()).toBe('a,bb,dddd');
+  });
 });

src/data-structures/tree/fenwick-tree/FenwickTree.js

@@ -0,0 +1,72 @@
+export default class FenwickTree {
+  /**
+   * Constructor creates empty fenwick tree of size 'arraySize',
+   * however, array size is size+1, because index is 1-based.
+   *
+   * @param  {number} arraySize
+   */
+  constructor(arraySize) {
+    this.arraySize = arraySize;
+
+    // Fill tree array with zeros.
+    this.treeArray = Array(this.arraySize + 1).fill(0);
+  }
+
+  /**
+   * Adds value to existing value at position.
+   *
+   * @param  {number} position
+   * @param  {number} value
+   * @return {FenwickTree}
+   */
+  increase(position, value) {
+    if (position < 1 || position > this.arraySize) {
+      throw new Error('Position is out of allowed range');
+    }
+
+    for (let i = position; i <= this.arraySize; i += (i & -i)) {
+      this.treeArray[i] += value;
+    }
+
+    return this;
+  }
+
+  /**
+   * Query sum from index 1 to position.
+   *
+   * @param  {number} position
+   * @return {number}
+   */
+  query(position) {
+    if (position < 1 || position > this.arraySize) {
+      throw new Error('Position is out of allowed range');
+    }
+
+    let sum = 0;
+
+    for (let i = position; i > 0; i -= (i & -i)) {
+      sum += this.treeArray[i];
+    }
+
+    return sum;
+  }
+
+  /**
+   * Query sum from index leftIndex to rightIndex.
+   *
+   * @param  {number} leftIndex
+   * @param  {number} rightIndex
+   * @return {number}
+   */
+  queryRange(leftIndex, rightIndex) {
+    if (leftIndex > rightIndex) {
+      throw new Error('Left index can not be greater then right one');
+    }
+
+    if (leftIndex === 1) {
+      return this.query(rightIndex);
+    }
+
+    return this.query(rightIndex) - this.query(leftIndex - 1);
+  }
+}

src/data-structures/tree/fenwick-tree/README.md

@@ -0,0 +1,37 @@
+# Fenwick Tree / Binary Indexed Tree
+
+A **Fenwick tree** or **binary indexed tree** is a data 
+structure that can efficiently update elements and 
+calculate prefix sums in a table of numbers.
+
+When compared with a flat array of numbers, the Fenwick tree achieves a 
+much better balance between two operations: element update and prefix sum 
+calculation. In a flat array of `n` numbers, you can either store the elements, 
+or the prefix sums. In the first case, computing prefix sums requires linear 
+time; in the second case, updating the array elements requires linear time 
+(in both cases, the other operation can be performed in constant time). 
+Fenwick trees allow both operations to be performed in `O(log n)` time. 
+This is achieved by representing the numbers as a tree, where the value of 
+each node is the sum of the numbers in that subtree. The tree structure allows 
+operations to be performed using only `O(log n)` node accesses.
+
+## Implementation Notes
+
+Binary Indexed Tree is represented as an array. Each node of Binary Indexed Tree 
+stores sum of some elements of given array. Size of Binary Indexed Tree is equal 
+to `n` where `n` is size of input array. In current implementation we have used 
+size as `n+1` for ease of implementation. All the indexes are 1-based.
+
+![Binary Indexed Tree](https://www.geeksforgeeks.org/wp-content/uploads/BITSum.png)
+
+On the picture below you may see animated example of 
+creation of binary indexed tree for the 
+array `[1, 2, 3, 4, 5]` by inserting one by one.
+
+![Fenwick Tree](https://upload.wikimedia.org/wikipedia/commons/d/dc/BITDemo.gif)
+
+## References
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Fenwick_tree)
+- [GeeksForGeeks](https://www.geeksforgeeks.org/binary-indexed-tree-or-fenwick-tree-2/)
+- [YouTube](https://www.youtube.com/watch?v=CWDQJGaN1gY&index=18&t=0s&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)

src/data-structures/tree/fenwick-tree/__test__/FenwickTree.test.js

@@ -0,0 +1,114 @@
+import FenwickTree from '../FenwickTree';
+
+describe('FenwickTree', () => {
+  it('should create empty fenwick tree of correct size', () => {
+    const tree1 = new FenwickTree(5);
+    expect(tree1.treeArray.length).toBe(5 + 1);
+
+    for (let i = 0; i < 5; i += 1) {
+      expect(tree1.treeArray[i]).toBe(0);
+    }
+
+    const tree2 = new FenwickTree(50);
+    expect(tree2.treeArray.length).toBe(50 + 1);
+  });
+
+  it('should create correct fenwick tree', () => {
+    const inputArray = [3, 2, -1, 6, 5, 4, -3, 3, 7, 2, 3];
+
+    const tree = new FenwickTree(inputArray.length);
+    expect(tree.treeArray.length).toBe(inputArray.length + 1);
+
+    inputArray.forEach((value, index) => {
+      tree.increase(index + 1, value);
+    });
+
+    expect(tree.treeArray).toEqual([0, 3, 5, -1, 10, 5, 9, -3, 19, 7, 9, 3]);
+
+    expect(tree.query(1)).toBe(3);
+    expect(tree.query(2)).toBe(5);
+    expect(tree.query(3)).toBe(4);
+    expect(tree.query(4)).toBe(10);
+    expect(tree.query(5)).toBe(15);
+    expect(tree.query(6)).toBe(19);
+    expect(tree.query(7)).toBe(16);
+    expect(tree.query(8)).toBe(19);
+    expect(tree.query(9)).toBe(26);
+    expect(tree.query(10)).toBe(28);
+    expect(tree.query(11)).toBe(31);
+
+    expect(tree.queryRange(1, 1)).toBe(3);
+    expect(tree.queryRange(1, 2)).toBe(5);
+    expect(tree.queryRange(2, 4)).toBe(7);
+    expect(tree.queryRange(6, 9)).toBe(11);
+
+    tree.increase(3, 1);
+
+    expect(tree.query(1)).toBe(3);
+    expect(tree.query(2)).toBe(5);
+    expect(tree.query(3)).toBe(5);
+    expect(tree.query(4)).toBe(11);
+    expect(tree.query(5)).toBe(16);
+    expect(tree.query(6)).toBe(20);
+    expect(tree.query(7)).toBe(17);
+    expect(tree.query(8)).toBe(20);
+    expect(tree.query(9)).toBe(27);
+    expect(tree.query(10)).toBe(29);
+    expect(tree.query(11)).toBe(32);
+
+    expect(tree.queryRange(1, 1)).toBe(3);
+    expect(tree.queryRange(1, 2)).toBe(5);
+    expect(tree.queryRange(2, 4)).toBe(8);
+    expect(tree.queryRange(6, 9)).toBe(11);
+  });
+
+  it('should correctly execute queries', () => {
+    const tree = new FenwickTree(5);
+
+    tree.increase(1, 4);
+    tree.increase(3, 7);
+
+    expect(tree.query(1)).toBe(4);
+    expect(tree.query(3)).toBe(11);
+    expect(tree.query(5)).toBe(11);
+    expect(tree.queryRange(2, 3)).toBe(7);
+
+    tree.increase(2, 5);
+    expect(tree.query(5)).toBe(16);
+
+    tree.increase(1, 3);
+    expect(tree.queryRange(1, 1)).toBe(7);
+    expect(tree.query(5)).toBe(19);
+    expect(tree.queryRange(1, 5)).toBe(19);
+  });
+
+  it('should throw exceptions', () => {
+    const tree = new FenwickTree(5);
+
+    const increaseAtInvalidLowIndex = () => {
+      tree.increase(0, 1);
+    };
+
+    const increaseAtInvalidHighIndex = () => {
+      tree.increase(10, 1);
+    };
+
+    const queryInvalidLowIndex = () => {
+      tree.query(0);
+    };
+
+    const queryInvalidHighIndex = () => {
+      tree.query(10);
+    };
+
+    const rangeQueryInvalidIndex = () => {
+      tree.queryRange(3, 2);
+    };
+
+    expect(increaseAtInvalidLowIndex).toThrowError();
+    expect(increaseAtInvalidHighIndex).toThrowError();
+    expect(queryInvalidLowIndex).toThrowError();
+    expect(queryInvalidHighIndex).toThrowError();
+    expect(rangeQueryInvalidIndex).toThrowError();
+  });
+});