Merge branch 'master' into patch-1

README.md

@@ -19,6 +19,9 @@ _Read this in other languages:_
 [_Español_](README.es-ES.md),
 [_Português_](README.pt-BR.md)
 
+*Note that this project is meant to be used for learning and researching purposes 
+only and it is **not** meant to be used for production.*
+
 ## Data Structures
 
 A data structure is a particular way of organizing and storing data in a computer so that it can
@@ -67,6 +70,7 @@ a set of rules that precisely define a sequence of operations.
   * `B` [Pascal's Triangle](src/algorithms/math/pascal-triangle)
   * `B` [Complex Number](src/algorithms/math/complex-number) - complex numbers and basic operations with them
   * `B` [Radian & Degree](src/algorithms/math/radian) - radians to degree and backwards conversion
+  * `B` [Fast Powering](src/algorithms/math/fast-powering)
   * `A` [Integer Partition](src/algorithms/math/integer-partition)
   * `A` [Liu Hui π Algorithm](src/algorithms/math/liu-hui) - approximate π calculations based on N-gons
   * `A` [Discrete Fourier Transform](src/algorithms/math/fourier-transform) - decompose a function of time (a signal) into the frequencies that make it up 
@@ -105,6 +109,9 @@ a set of rules that precisely define a sequence of operations.
   * `B` [Shellsort](src/algorithms/sorting/shell-sort)
   * `B` [Counting Sort](src/algorithms/sorting/counting-sort)
   * `B` [Radix Sort](src/algorithms/sorting/radix-sort)
+* **Linked Lists**
+  * `B` [Straight Traversal](src/algorithms/linked-list/traversal)
+  * `B` [Reverse Traversal](src/algorithms/linked-list/reverse-traversal)
 * **Trees**
   * `B` [Depth-First Search](src/algorithms/tree/depth-first-search) (DFS)
   * `B` [Breadth-First Search](src/algorithms/tree/breadth-first-search) (BFS)
@@ -163,6 +170,7 @@ algorithm is an abstraction higher than a computer program.
   * `B` [Tree Depth-First Search](src/algorithms/tree/depth-first-search) (DFS)
   * `B` [Graph Depth-First Search](src/algorithms/graph/depth-first-search) (DFS)
   * `B` [Jump Game](src/algorithms/uncategorized/jump-game)
+  * `B` [Fast Powering](src/algorithms/math/fast-powering)
   * `A` [Permutations](src/algorithms/sets/permutations) (with and without repetitions)
   * `A` [Combinations](src/algorithms/sets/combinations) (with and without repetitions)
 * **Dynamic Programming** - build up a solution using previously found sub-solutions

src/algorithms/linked-list/reverse-traversal/README.md

@@ -0,0 +1,19 @@
+# Reversed Linked List Traversal
+
+The task is to traverse the given linked list in reversed order.
+
+For example for the following linked list: 
+
+![](https://upload.wikimedia.org/wikipedia/commons/6/6d/Singly-linked-list.svg)
+
+The order of traversal should be:
+
+```text
+37 → 99 → 12
+```
+
+The time complexity is `O(n)` because we visit every node only once.
+
+## Reference
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Linked_list)

src/algorithms/linked-list/reverse-traversal/__test__/reverseTraversal.test.js

@@ -0,0 +1,36 @@
+import LinkedList from '../../../../data-structures/linked-list/LinkedList';
+import reverseTraversal from '../reverseTraversal';
+
+describe('reverseTraversal', () => {
+  it('should traverse linked list in reverse order', () => {
+    const linkedList = new LinkedList();
+
+    linkedList
+      .append(1)
+      .append(2)
+      .append(3);
+
+    const traversedNodeValues = [];
+    const traversalCallback = (nodeValue) => {
+      traversedNodeValues.push(nodeValue);
+    };
+
+    reverseTraversal(linkedList, traversalCallback);
+
+    expect(traversedNodeValues).toEqual([3, 2, 1]);
+  });
+});
+
+
+// it('should reverse traversal the linked list with callback', () => {
+//   const linkedList = new LinkedList();
+//
+//   linkedList
+//     .append(1)
+//     .append(2)
+//     .append(3);
+//
+//   expect(linkedList.toString()).toBe('1,2,3');
+//   expect(linkedList.reverseTraversal(linkedList.head, value => value * 2)).toEqual([6, 4, 2]);
+//   expect(() => linkedList.reverseTraversal(linkedList.head)).toThrow();
+// });

src/algorithms/linked-list/reverse-traversal/reverseTraversal.js

@@ -0,0 +1,24 @@
+/**
+ * Traversal callback function.
+ * @callback traversalCallback
+ * @param {*} nodeValue
+ */
+
+/**
+ * @param {LinkedListNode} node
+ * @param {traversalCallback} callback
+ */
+function reverseTraversalRecursive(node, callback) {
+  if (node) {
+    reverseTraversalRecursive(node.next, callback);
+    callback(node.value);
+  }
+}
+
+/**
+ * @param {LinkedList} linkedList
+ * @param {traversalCallback} callback
+ */
+export default function reverseTraversal(linkedList, callback) {
+  reverseTraversalRecursive(linkedList.head, callback);
+}

src/algorithms/linked-list/traversal/README.md

@@ -0,0 +1,19 @@
+# Linked List Traversal
+
+The task is to traverse the given linked list in straight order.
+
+For example for the following linked list: 
+
+![](https://upload.wikimedia.org/wikipedia/commons/6/6d/Singly-linked-list.svg)
+
+The order of traversal should be:
+
+```text
+12 → 99 → 37
+```
+
+The time complexity is `O(n)` because we visit every node only once.
+
+## Reference
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Linked_list)

src/algorithms/linked-list/traversal/__test__/traversal.test.js

@@ -0,0 +1,22 @@
+import LinkedList from '../../../../data-structures/linked-list/LinkedList';
+import traversal from '../traversal';
+
+describe('traversal', () => {
+  it('should traverse linked list', () => {
+    const linkedList = new LinkedList();
+
+    linkedList
+      .append(1)
+      .append(2)
+      .append(3);
+
+    const traversedNodeValues = [];
+    const traversalCallback = (nodeValue) => {
+      traversedNodeValues.push(nodeValue);
+    };
+
+    traversal(linkedList, traversalCallback);
+
+    expect(traversedNodeValues).toEqual([1, 2, 3]);
+  });
+});

src/algorithms/linked-list/traversal/traversal.js

@@ -0,0 +1,18 @@
+/**
+ * Traversal callback function.
+ * @callback traversalCallback
+ * @param {*} nodeValue
+ */
+
+/**
+ * @param {LinkedList} linkedList
+ * @param {traversalCallback} callback
+ */
+export default function traversal(linkedList, callback) {
+  let currentNode = linkedList.head;
+
+  while (currentNode) {
+    callback(currentNode.value);
+    currentNode = currentNode.next;
+  }
+}

src/algorithms/math/bits/README.md

@@ -35,6 +35,22 @@ This method is a combination of "Clear Bit" and "Set Bit" methods.
 
 > See [updateBit.js](updateBit.js) for further details.
 
+#### isEven
+
+This method determines if the number provided is even.
+It is based on the fact that odd numbers have their last
+right bit to be set to 1.
+
+```text
+Number: 5 = 0b0101
+isEven: false
+
+Number: 4 = 0b0100
+isEven: true
+```
+
+> See [isEven.js](isEven.js) for further details.
+
 #### Multiply By Two
 
 This method shifts original number by one bit to the left.
@@ -91,7 +107,26 @@ inverting all of the bits of the number and adding 1 to it.
 
 > See [switchSign.js](switchSign.js) for further details.
 
-#### Multiply Two Numbers
+#### Multiply Two Signed Numbers
+
+This method multiplies two signed integer numbers using bitwise operators.
+This method is based on the following facts:
+
+```text
+a * b can be written in the below formats:
+  0                     if a is zero or b is zero or both a and b are zeroes
+  2a * (b/2)            if b is even
+  2a * (b - 1)/2 + a    if b is odd and positive
+  2a * (b + 1)/2 - a    if b is odd and negative
+```
+
+The advantage of this approach is that in each recursive step one of the operands
+reduces to half its original value. Hence, the run time complexity is `O(log(b)` where `b` is
+the operand that reduces to half on each recursive step.
+
+> See [multiply.js](multiply.js) for further details.
+
+#### Multiply Two Unsigned Numbers
 
 This method multiplies two integer numbers using bitwise operators.
 This method is based on that "Every number can be denoted as the sum of powers of 2".

src/algorithms/math/bits/__test__/isEven.test.js

@@ -0,0 +1,19 @@
+import isEven from '../isEven';
+
+describe('isEven', () => {
+  it('should detect if a number is even', () => {
+    expect(isEven(0)).toBe(true);
+    expect(isEven(2)).toBe(true);
+    expect(isEven(-2)).toBe(true);
+    expect(isEven(1)).toBe(false);
+    expect(isEven(-1)).toBe(false);
+    expect(isEven(-3)).toBe(false);
+    expect(isEven(3)).toBe(false);
+    expect(isEven(8)).toBe(true);
+    expect(isEven(9)).toBe(false);
+    expect(isEven(121)).toBe(false);
+    expect(isEven(122)).toBe(true);
+    expect(isEven(1201)).toBe(false);
+    expect(isEven(1202)).toBe(true);
+  });
+});

src/algorithms/math/bits/__test__/multiply.test.js

@@ -0,0 +1,18 @@
+import multiply from '../multiply';
+
+describe('multiply', () => {
+  it('should multiply two numbers', () => {
+    expect(multiply(0, 0)).toBe(0);
+    expect(multiply(2, 0)).toBe(0);
+    expect(multiply(0, 2)).toBe(0);
+    expect(multiply(1, 2)).toBe(2);
+    expect(multiply(2, 1)).toBe(2);
+    expect(multiply(6, 6)).toBe(36);
+    expect(multiply(-2, 4)).toBe(-8);
+    expect(multiply(4, -2)).toBe(-8);
+    expect(multiply(-4, -4)).toBe(16);
+    expect(multiply(4, -5)).toBe(-20);
+    expect(multiply(2, 121)).toBe(242);
+    expect(multiply(121, 2)).toBe(242);
+  });
+});

src/algorithms/math/bits/isEven.js

@@ -0,0 +1,7 @@
+/**
+ * @param {number} number
+ * @return {boolean}
+ */
+export default function isEven(number) {
+  return (number & 1) === 0;
+}

src/algorithms/math/bits/multiply.js

@@ -0,0 +1,40 @@
+import multiplyByTwo from './multiplyByTwo';
+import divideByTwo from './divideByTwo';
+import isEven from './isEven';
+
+/**
+ * Multiply two signed numbers using bitwise operations.
+ *
+ * If a is zero or b is zero or if both a and b are zeros:
+ * multiply(a, b) = 0
+ *
+ * If b is even:
+ * multiply(a, b) = multiply(2a, b/2)
+ *
+ * If b is odd and b is positive:
+ * multiply(a, b) = multiply(2a, (b-1)/2) + a
+ *
+ * If b is odd and b is negative:
+ * multiply(a, b) = multiply(2a, (b+1)/2) - a
+ *
+ * Time complexity: O(log b)
+ *
+ * @param {number} a
+ * @param {number} b
+ * @return {number}
+ */
+export default function multiply(a, b) {
+  // If a is zero or b is zero or if both a and b are zeros then the production is also zero.
+  if (b === 0 || a === 0) {
+    return 0;
+  }
+
+  // Otherwise we will have four different cases that are described above.
+  const multiplyByOddPositive = () => multiply(multiplyByTwo(a), divideByTwo(b - 1)) + a;
+  const multiplyByOddNegative = () => multiply(multiplyByTwo(a), divideByTwo(b + 1)) - a;
+
+  const multiplyByEven = () => multiply(multiplyByTwo(a), divideByTwo(b));
+  const multiplyByOdd = () => (b > 0 ? multiplyByOddPositive() : multiplyByOddNegative());
+
+  return isEven(b) ? multiplyByEven() : multiplyByOdd();
+}

src/algorithms/math/fast-powering/README.md

@@ -0,0 +1,68 @@
+# Fast Powering Algorithm
+
+**The power of a number** says how many times to use the number in a 
+multiplication.
+
+It is written as a small number to the right and above the base number.
+
+![Power](https://www.mathsisfun.com/algebra/images/exponent-8-2.svg)
+
+## Naive Algorithm Complexity
+
+How to find `a` raised to the power `b`?
+
+We multiply `a` to itself, `b` times. That 
+is, `a^b = a * a * a * ... * a` (`b` occurrences of `a`).
+
+This operation will take `O(n)` time since we need to do multiplication operation
+exactly `n` times.
+
+## Fast Power Algorithm
+
+Can we do better than naive algorithm does? Yes we may solve the task of
+ powering in `O(log(n))` time.
+
+The algorithm uses divide and conquer approach to compute power. Currently the 
+algorithm work for two positive integers `X` and `Y`.
+
+The idea behind the algorithm is based on the fact that:
+
+For **even** `Y`:
+
+```text
+X^Y = X^(Y/2) * X^(Y/2) 
+```
+
+For **odd** `Y`:
+
+```text
+X^Y = X^(Y//2) * X^(Y//2) * X
+where Y//2 is result of division of Y by 2 without reminder.
+```
+
+**For example**
+
+```text
+2^4 = (2 * 2) * (2 * 2) = (2^2) * (2^2)
+```
+
+```text
+2^5 = (2 * 2) * (2 * 2) * 2 = (2^2) * (2^2) * (2)
+```
+
+Now, since on each step we need to compute the same `X^(Y/2)` power twice we may optimise 
+it by saving it to some intermediate variable to avoid its duplicate calculation. 
+
+**Time Complexity**
+
+Since each iteration we split the power by half then we will call function 
+recursively `log(n)` times. This the time complexity of the algorithm is reduced to:
+
+```text
+O(log(n))
+``` 
+
+## References
+
+- [YouTube](https://www.youtube.com/watch?v=LUWavfN9zEo&index=80&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8&t=0s)
+- [Wikipedia](https://en.wikipedia.org/wiki/Exponentiation_by_squaring)

src/algorithms/math/fast-powering/__test__/fastPowering.test.js

@@ -0,0 +1,23 @@
+import fastPowering from '../fastPowering';
+
+describe('fastPowering', () => {
+  it('should compute power in log(n) time', () => {
+    expect(fastPowering(1, 1)).toBe(1);
+    expect(fastPowering(2, 0)).toBe(1);
+    expect(fastPowering(2, 2)).toBe(4);
+    expect(fastPowering(2, 3)).toBe(8);
+    expect(fastPowering(2, 4)).toBe(16);
+    expect(fastPowering(2, 5)).toBe(32);
+    expect(fastPowering(2, 6)).toBe(64);
+    expect(fastPowering(2, 7)).toBe(128);
+    expect(fastPowering(2, 8)).toBe(256);
+    expect(fastPowering(3, 4)).toBe(81);
+    expect(fastPowering(190, 2)).toBe(36100);
+    expect(fastPowering(11, 5)).toBe(161051);
+    expect(fastPowering(13, 11)).toBe(1792160394037);
+    expect(fastPowering(9, 16)).toBe(1853020188851841);
+    expect(fastPowering(16, 16)).toBe(18446744073709552000);
+    expect(fastPowering(7, 21)).toBe(558545864083284000);
+    expect(fastPowering(100, 9)).toBe(1000000000000000000);
+  });
+});

src/algorithms/math/fast-powering/fastPowering.js

@@ -0,0 +1,30 @@
+/**
+ * Fast Powering Algorithm.
+ * Recursive implementation to compute power.
+ *
+ * Complexity: log(n)
+ *
+ * @param {number} base - Number that will be raised to the power.
+ * @param {number} power - The power that number will be raised to.
+ * @return {number}
+ */
+export default function fastPowering(base, power) {
+  if (power === 0) {
+    // Anything that is raised to the power of zero is 1.
+    return 1;
+  }
+
+  if (power % 2 === 0) {
+    // If the power is even...
+    // we may recursively redefine the result via twice smaller powers:
+    // x^8 = x^4 * x^4.
+    const multiplier = fastPowering(base, power / 2);
+    return multiplier * multiplier;
+  }
+
+  // If the power is odd...
+  // we may recursively redefine the result via twice smaller powers:
+  // x^9 = x^4 * x^4 * x.
+  const multiplier = fastPowering(base, Math.floor(power / 2));
+  return multiplier * multiplier * base;
+}

src/data-structures/doubly-linked-list/DoublyLinkedList.js

@@ -230,4 +230,32 @@ export default class DoublyLinkedList {
   toString(callback) {
     return this.toArray().map(node => node.toString(callback)).toString();
   }
+
+  /**
+   * Reverse a linked list.
+   * @returns {DoublyLinkedList}
+   */
+  reverse() {
+    let currNode = this.head;
+    let prevNode = null;
+    let nextNode = null;
+
+    while (currNode) {
+      // Store next node.
+      nextNode = currNode.next;
+
+      // Change next node of the current node so it would link to previous node.
+      currNode.next = prevNode;
+
+      // Move prevNode and currNode nodes one step forward.
+      prevNode = currNode;
+      currNode = nextNode;
+    }
+
+    // Reset head and tail.
+    this.tail = this.head;
+    this.head = prevNode;
+
+    return this;
+  }
 }

src/data-structures/doubly-linked-list/__test__/DoublyLinkedList.test.js

@@ -228,4 +228,30 @@ describe('DoublyLinkedList', () => {
     expect(node.value.customValue).toBe('test2');
     expect(linkedList.find({ value: 2, customValue: 'test5' })).toBeNull();
   });
+
+  it('should reverse linked list', () => {
+    const linkedList = new DoublyLinkedList();
+
+    // Add test values to linked list.
+    linkedList
+      .append(1)
+      .append(2)
+      .append(3);
+
+    expect(linkedList.toString()).toBe('1,2,3');
+    expect(linkedList.head.value).toBe(1);
+    expect(linkedList.tail.value).toBe(3);
+
+    // Reverse linked list.
+    linkedList.reverse();
+    expect(linkedList.toString()).toBe('3,2,1');
+    expect(linkedList.head.value).toBe(3);
+    expect(linkedList.tail.value).toBe(1);
+
+    // Reverse linked list back to initial state.
+    linkedList.reverse();
+    expect(linkedList.toString()).toBe('1,2,3');
+    expect(linkedList.head.value).toBe(1);
+    expect(linkedList.tail.value).toBe(3);
+  });
 });

src/data-structures/linked-list/LinkedList.js

@@ -207,4 +207,32 @@ export default class LinkedList {
   toString(callback) {
     return this.toArray().map(node => node.toString(callback)).toString();
   }
+
+  /**
+   * Reverse a linked list.
+   * @returns {LinkedList}
+   */
+  reverse() {
+    let currNode = this.head;
+    let prevNode = null;
+    let nextNode = null;
+
+    while (currNode) {
+      // Store next node.
+      nextNode = currNode.next;
+
+      // Change next node of the current node so it would link to previous node.
+      currNode.next = prevNode;
+
+      // Move prevNode and currNode nodes one step forward.
+      prevNode = currNode;
+      currNode = nextNode;
+    }
+
+    // Reset head and tail.
+    this.tail = this.head;
+    this.head = prevNode;
+
+    return this;
+  }
 }

src/data-structures/linked-list/README.md

@@ -110,7 +110,7 @@ Traverse(head)
   Pre: head is the head node in the list
   Post: the items in the list have been traversed
   n ← head
-  while n = 0
+  while n != ø
     yield n.value
     n ← n.next
   end while
@@ -123,11 +123,11 @@ end Traverse
 ReverseTraversal(head, tail)
   Pre: head and tail belong to the same list
   Post: the items in the list have been traversed in reverse order
-  if tail = ø
+  if tail != ø
     curr ← tail
-    while curr = head
+    while curr != head
       prev ← head
-      while prev.next = curr
+      while prev.next != curr
         prev ← prev.next
       end while
       yield curr.value

src/data-structures/linked-list/__test__/LinkedList.test.js

@@ -217,4 +217,30 @@ describe('LinkedList', () => {
     expect(node.value.customValue).toBe('test2');
     expect(linkedList.find({ value: 2, customValue: 'test5' })).toBeNull();
   });
+
+  it('should reverse linked list', () => {
+    const linkedList = new LinkedList();
+
+    // Add test values to linked list.
+    linkedList
+      .append(1)
+      .append(2)
+      .append(3);
+
+    expect(linkedList.toString()).toBe('1,2,3');
+    expect(linkedList.head.value).toBe(1);
+    expect(linkedList.tail.value).toBe(3);
+
+    // Reverse linked list.
+    linkedList.reverse();
+    expect(linkedList.toString()).toBe('3,2,1');
+    expect(linkedList.head.value).toBe(3);
+    expect(linkedList.tail.value).toBe(1);
+
+    // Reverse linked list back to initial state.
+    linkedList.reverse();
+    expect(linkedList.toString()).toBe('1,2,3');
+    expect(linkedList.head.value).toBe(1);
+    expect(linkedList.tail.value).toBe(3);
+  });
 });

src/data-structures/stack/Stack.js

@@ -2,8 +2,8 @@ import LinkedList from '../linked-list/LinkedList';
 
 export default class Stack {
   constructor() {
-    // We're going to implement Queue based on LinkedList since this
-    // structures a quite similar. Compare push/pop operations of the Stack
+    // We're going to implement Stack based on LinkedList since these
+    // structures are quite similar. Compare push/pop operations of the Stack
     // with append/deleteTail operations of LinkedList.
     this.linkedList = new LinkedList();
   }
@@ -12,7 +12,7 @@ export default class Stack {
    * @return {boolean}
    */
   isEmpty() {
-    // The queue is empty in case if its linked list don't have tail.
+    // The stack is empty if its linked list doesn't have a tail.
     return !this.linkedList.tail;
   }
 
@@ -21,7 +21,7 @@ export default class Stack {
    */
   peek() {
     if (this.isEmpty()) {
-      // If linked list is empty then there is nothing to peek from.
+      // If the linked list is empty then there is nothing to peek from.
       return null;
     }
 
@@ -34,7 +34,7 @@ export default class Stack {
    */
   push(value) {
     // Pushing means to lay the value on top of the stack. Therefore let's just add
-    // new value at the end of the linked list.
+    // the new value at the end of the linked list.
     this.linkedList.append(value);
   }
 
@@ -42,8 +42,8 @@ export default class Stack {
    * @return {*}
    */
   pop() {
-    // Let's try to delete the last node from linked list (the tail).
-    // If there is no tail in linked list (it is empty) just return null.
+    // Let's try to delete the last node (the tail) from the linked list.
+    // If there is no tail (the linked list is empty) just return null.
     const removedTail = this.linkedList.deleteTail();
     return removedTail ? removedTail.value : null;
   }