Merge pull request knaxus#142 from knaxus/codeCoverage

Increase code coverage

Author: ashokdey

src/_DataStructures_/DoublyLinkedList/Node.js

@@ -0,0 +1,8 @@
+class Node {
+  constructor(data, previous, next) {
+    this.data = data;
+    this.previous = previous;
+    this.next = next;
+  }
+}
+module.exports = Node;

src/_DataStructures_/DoublyLinkedList/doublyLinkedList.test.js

@@ -0,0 +1,44 @@
+const DLL = require('.');
+
+describe('Doubly Linked List', () => {
+  it('Doubly linked list should be class', () => {
+    expect(typeof DLL.prototype.constructor).toEqual('function');
+  });
+
+  const doublyLinkedList = new DLL();
+
+  it('It should create a DLL', () => {
+    expect(doublyLinkedList.head.next).toEqual(doublyLinkedList.tail);
+    expect(doublyLinkedList.tail.previous).toEqual(doublyLinkedList.head);
+    expect(doublyLinkedList.length()).toEqual(0);
+  });
+
+  it('It should add at beginning (addAtBeginning)', () => {
+    doublyLinkedList.addAtBeginning(1);
+    doublyLinkedList.addAtBeginning(2);
+    doublyLinkedList.addAtBeginning(3);
+    expect(doublyLinkedList.traverse()).toEqual([3, 2, 1]);
+  });
+
+  it('It should add at end (addAtEnd)', () => {
+    doublyLinkedList.addAtEnd(1);
+    doublyLinkedList.addAtEnd(2);
+    doublyLinkedList.addAtEnd(3);
+    expect(doublyLinkedList.traverse()).toEqual([3, 2, 1, 1, 2, 3]);
+  });
+
+  it('It should remove at beginning (removeAtBeginning)', () => {
+    doublyLinkedList.removeAtBeginning();
+    doublyLinkedList.removeAtBeginning();
+    doublyLinkedList.removeAtBeginning();
+    expect(doublyLinkedList.traverse()).toEqual([1, 2, 3]);
+  });
+
+  it('It should remove at end (removeAtEnd)', () => {
+    doublyLinkedList.removeAtEnd();
+    doublyLinkedList.removeAtEnd();
+    doublyLinkedList.removeAtEnd();
+
+    expect(doublyLinkedList.traverse()).toEqual([]);
+  });
+});

src/_DataStructures_/DoublyLinkedList/index.js

@@ -1,11 +1,5 @@
 /* eslint-disable class-methods-use-this */
-class Node {
-  constructor(data, previous, next) {
-    this.data = data;
-    this.previous = previous;
-    this.next = next;
-  }
-}
+const Node = require('./Node');
 
 class DoublyLinkedList {
   constructor() {

src/_DataStructures_/LinkedList/LinkedList.test.js

@@ -68,6 +68,7 @@ describe('Data Structures: Linked Lists', () => {
         list.addAtEnd(10);
 
         expect(list.length()).toEqual(4);
+        expect(list.traverseList()).toEqual([15, 23, 33, 10]);
       });
     });
 

src/_DataStructures_/Queue/Queue.test.js

@@ -1,7 +1,7 @@
 const Queue = require('.');
 
 describe('Data Structure : Queue', () => {
-  it('Should be class', () => {
+  it('Queue should be class', () => {
     expect(typeof Queue.prototype.constructor).toEqual('function');
   });
 
@@ -53,6 +53,30 @@ describe('Data Structure : Queue', () => {
       expect(queue.dequeue()).toEqual(1);
       expect(queue.dequeue()).toEqual(4);
       expect(queue.dequeue()).toEqual(3);
+      expect(queue.dequeue()).toEqual(null);
+    });
+
+    it('Shoud return size of Queue', () => {
+      const queue2 = new Queue();
+      queue2.enqueue(2);
+      queue2.enqueue(1);
+      queue2.enqueue(4);
+      queue2.enqueue(3);
+      expect(queue2.length()).toEqual(4);
+    });
+
+    it('Should Destroy Queue', () => {
+      queue.destroy();
+      expect(queue.length()).toEqual(0);
+    });
+
+    it('Override and throw error for other LL methods', () => {
+      expect(() => { queue.addAtBeginning(); }).toThrowError('Not Allowed');
+      expect(() => { queue.addAt(); }).toThrowError('Not Allowed');
+      expect(() => { queue.removeFromEnd(); }).toThrowError('Not Allowed');
+      expect(() => { queue.getLast(); }).toThrowError('Not Allowed');
+      expect(() => { queue.getAt(); }).toThrowError('Not Allowed');
+      expect(() => { queue.removeAt(); }).toThrowError('Not Allowed');
     });
   });
 });

src/_DataStructures_/Stack/postfix-expression-evaluation/index.js

@@ -43,7 +43,7 @@ function evaluatePostfixExpression(expression) {
           s.push(val2 / val1);
           break;
         default:
-          break;
+          throw new Error('Operation is not valid');
       }
     }
   }

src/_DataStructures_/Stack/postfix-expression-evaluation/postfix-expression-evaluation.test.js

@@ -58,5 +58,8 @@ describe('Postfix expression evaluation', () => {
     test.each(invalidExpressions)('running for %p', (expression) => {
       expect(() => evaluatePostfixExpression(expression)).toThrow(ERROR_STRING);
     });
+
+    expect(() => evaluatePostfixExpression('1&2')).toThrow('Operation is not valid');
+
   });
 });

src/_DataStructures_/Trees/BinarySearchTree/BinarySearchTree.test.js

@@ -0,0 +1,18 @@
+const BinarySearchTree = require('./index');
+
+describe('Binary Search Tree', () => {
+  describe('Is Empty', () => {
+    const bst = new BinarySearchTree(6);
+    const keys = [4, 9, 2, 5, 8, 12];
+    keys.forEach(el => bst.add(el));
+    it('should return False when BST is not empty', () => {
+      expect(bst.isEmpty()).toEqual(false);
+    });
+
+    it('should return True when BST is empty', () => {
+      keys.push(6);
+      keys.forEach(el => bst.remove(el));
+      expect(bst.isEmpty()).toEqual(true);
+    });
+  });
+});

src/_DataStructures_/Trees/BinarySearchTree/bst-isEmpty.test.js

@@ -0,0 +1,18 @@
+const BinarySearchTree = require('./index');
+
+describe('Binary Search Tree', () => {
+  describe('Find maximum value in BST', () => {
+    const bst = new BinarySearchTree(6);
+    const keys = [4, 9, 2, 5, 8, 12];
+    keys.forEach(el => bst.add(el));
+
+    it('It should expect maximum key', () => {
+      expect(bst.getMaximum()).toEqual(12);
+    });
+
+    it('It should expect new maximum key added in BST', () => {
+      bst.add(20);
+      expect(bst.getMaximum()).toEqual(20);
+    });
+  });
+});

src/_DataStructures_/Trees/BinarySearchTree/bst-maximum.test.js

@@ -0,0 +1,18 @@
+const BinarySearchTree = require('./index');
+
+describe('Binary Search Tree', () => {
+  describe('It should Find the minimum value in BST', () => {
+    const bst = new BinarySearchTree(6);
+    const keys = [4, 9, 2, 5, 8, 12];
+    keys.forEach(el => bst.add(el));
+
+    it('It should expect minimum key', () => {
+      expect(bst.getMinimum()).toEqual(2);
+    });
+
+    it('It should expect new minimum key added to BST', () => {
+      bst.add(1);
+      expect(bst.getMinimum()).toEqual(1);
+    });
+  });
+});

src/_DataStructures_/Trees/BinarySearchTree/bst-minimum.test.js

@@ -0,0 +1,32 @@
+const BST = require('.');
+
+describe('Data Structure : Binary Search Tree', () => {
+  it('Binary Search Tree should be a Class', () => {
+    expect(typeof BST.prototype.constructor).toEqual('function');
+  });
+
+  describe('Binary Search Tree API', () => {
+    let bst = null;
+
+    beforeEach(() => {
+      bst = new BST(5);
+    });
+
+    it('Should delete() an element from Binary Search Tree', () => {
+      bst.add(4);
+      bst.add(9);
+      bst.add(2);
+      bst.delete(bst.root, 4);
+      expect(bst.traverseInorder()).toEqual([2, 5, 9]);
+      bst.delete(bst.root, 2);
+      expect(bst.traverseInorder()).toEqual([5, 9]);
+    });
+
+    it('Should return NULL if root is empty', () => {
+      const bst2 = new BST(6);
+      bst2.remove(6);
+      bst2.remove(9);
+      expect(bst2.root).toEqual(null);
+    });
+  });
+});

src/_DataStructures_/Trees/BinarySearchTree/bst-remove.test.js

@@ -0,0 +1,17 @@
+const BinarySearchTree = require('./index');
+
+describe('Binary Search Tree', () => {
+  describe('It should Find the key in BST', () => {
+    const bst = new BinarySearchTree(6);
+    const keys = [4, 9, 2, 5, 8, 12];
+    keys.forEach(el => bst.add(el));
+
+    it('It should return true for 8', () => {
+      expect(bst.searchFor(8)).toEqual(true);
+    });
+
+    it('It should return false for 100', () => {
+      expect(bst.searchFor(100)).toEqual(false);
+    });
+  });
+});

src/_DataStructures_/Trees/BinarySearchTree/bst-search.test.js

@@ -1,5 +1,5 @@
-const BinarySearchTree = require('./index');
-const heightOfBST = require('./height-of-bst/index');
+const BinarySearchTree = require('../index');
+const heightOfBST = require('./index');
 
 describe('Binary search tree traversals', () => {
   let bst;
@@ -8,12 +8,8 @@ describe('Binary search tree traversals', () => {
     it('should create BST', () => {
       // Creates BST
       bst = new BinarySearchTree(6);
-      bst.add(4);
-      bst.add(9);
-      bst.add(2);
-      bst.add(5);
-      bst.add(8);
-      bst.add(12);
+      const keys = [4, 9, 2, 5, 8, 12];
+      keys.forEach(el => bst.add(el));
     });
   });
 
@@ -48,4 +44,14 @@ describe('Binary search tree traversals', () => {
       expect(heightOfBST(bst.root)).toEqual(2);
     });
   });
+
+  describe('When root left subtree height is greater than right', () => {
+    const bst2 = new BinarySearchTree(10);
+    const keys = [11, 20, 9, 8, 7, 6, 5, 4];
+    keys.forEach(el => bst2.add(el));
+
+    it('should return height of BST ', () => {
+      expect(heightOfBST(bst2.root)).toEqual(7);
+    });
+  });
 });

src/_DataStructures_/Trees/BinarySearchTree/bst-deletion.test.js src/_DataStructures_/Trees/BinarySearchTree/height-of-bst/height-of-bst.test.js

@@ -1,3 +1,4 @@
+/* eslint-disable consistent-return */
 const Node = require('./Node');
 
 class BinarySearchTree {
@@ -23,7 +24,6 @@ class BinarySearchTree {
       root.rightChild = this.insert(root.rightChild, value);
       return root;
     }
-    return root;
   }
 
   preorder(root) {
@@ -80,7 +80,6 @@ class BinarySearchTree {
     if (value > root.value) {
       return this.search(root.rightChild, value);
     }
-    return false;
   }
 
   delete(root, value) {
@@ -169,7 +168,7 @@ class BinarySearchTree {
   }
 
   remove(value) {
-    return this.delete(this.root, value);
+    this.root = this.delete(this.root, value);
   }
 }
 

src/_DataStructures_/Trees/BinarySearchTree/index.js

@@ -3,22 +3,19 @@
  *
  * Given values of two values n1 and n2 in a Binary Search Tree, find the Lowest Common Ancestor (LCA). You may assume that both the values exist in the tree.
  */
- 
-function lca(node, n1, n2) {
-  if (node == null)
-    return null;
+
+function lowestCommonAncestor(node, n1, n2) {
+  if (node === null) return null;
 
   // If both n1 and n2 are smaller than root, then LCA lies in left
-  if (node.value > n1 && node.value > n2)
-    return lca(node.leftChild, n1, n2);
+  if (node.value > n1 && node.value > n2) { return lowestCommonAncestor(node.leftChild, n1, n2); }
 
   // If both n1 and n2 are greater than root, then LCA lies in right
-  if (node.value < n1 && node.value < n2)
-    return lca(node.rightChild, n1, n2);
+  if (node.value < n1 && node.value < n2) { return lowestCommonAncestor(node.rightChild, n1, n2); }
 
   return node;
 }
 
 module.exports = {
-  lca,
+  lowestCommonAncestor,
 };

src/_DataStructures_/Trees/BinarySearchTree/lowest-common-ancestor/index.js

@@ -1,28 +1,24 @@
-const { lca } = require('.');
+const { lowestCommonAncestor } = require('.');
 const BinarySearchTree = require('../index');
 
 // Quick JSON equivalent
 // {"left":{"left":{"data":4},"right":{"left":{"data":10},"right":{"data":14},"data":12},"data":8},"right":{"data":22},"data":20}
 
-describe('LCA', () => {
+describe('Lowest Common Ancestor in BST', () => {
+  const bst = new BinarySearchTree(20);
+  const keys = [22, 8, 12, 4, 14, 10];
+  keys.forEach(el => bst.add(el));
 
-  let bst = new BinarySearchTree(20);
-  bst.add(22);
-  bst.add(8);
-  bst.add(12);
-  bst.add(4);
-  bst.add(14);
-  bst.add(10);
-
-  it('Should return 12', () => {
-    expect(lca(bst.root, 10, 14).value).toEqual(12);
-  });
-  
-  it('Should return 8', () => {
-    expect(lca(bst.root, 14, 8).value).toEqual(8);
+  it('Should return Lowest Common Ancestor Node ', () => {
+    expect(lowestCommonAncestor(bst.root, 10, 14).value).toEqual(12);
+    expect(lowestCommonAncestor(bst.root, 14, 8).value).toEqual(8);
+    expect(lowestCommonAncestor(bst.root, 10, 22).value).toEqual(20);
   });
-  
-  it('Should return 20', () => {
-    expect(lca(bst.root, 10, 22).value).toEqual(20);
+
+  const bst2 = new BinarySearchTree(6);
+  bst2.remove(6);
+
+  it('Should return Null when root is null', () => {
+    expect(lowestCommonAncestor(bst2.root, 10, 22)).toEqual(null);
   });
 });

src/_DataStructures_/Trees/BinarySearchTree/lowest-common-ancestor/index.test.js

@@ -1,6 +1,6 @@
-const totalWordsInTrie = require('./index')
-const Trie = require('../index');
 const assert = require('assert');
+const totalWordsInTrie = require('./index');
+const Trie = require('../index');
 
 describe('Data Structure : Trie', () => {
   it('Should be class of type Trie', () => {
@@ -11,24 +11,24 @@ describe('Data Structure : Trie', () => {
   describe('Trie', () => {
 
     it('Should return 6.', () => {
-      let newTrie = new Trie();
+      const newTrie = new Trie();
       const words = ['bed', 'ball', 'apple', 'java', 'javascript', 'bed'];
       words.forEach(word => newTrie.insert(word));
-      result = totalWordsInTrie(newTrie.root);
+      const result = totalWordsInTrie(newTrie.root);
       assert.equal(result, 6);
     });
 
     it('Should return 0.', () => {
-      let newTrie = new Trie();
-      result = totalWordsInTrie(newTrie.root);
+      const newTrie = new Trie();
+      const result = totalWordsInTrie(newTrie.root);
       assert.equal(result, 0);
     });
 
     it('Should return 6.', () => {
-      let newTrie = new Trie();
+      const newTrie = new Trie();
       const words = ['bed', 'ball','', 'apple', 'java', 'javascript', 'bed'];
       words.forEach(word => newTrie.insert(word));
-      result = totalWordsInTrie(newTrie.root);
+      const result = totalWordsInTrie(newTrie.root);
       assert.equal(result, 6);
     });
   });

src/_DataStructures_/Trees/Trie/total-words-in-trie/total-words-in-trie.test.js

@@ -119,4 +119,76 @@ describe('A*', () => {
       expect(() => { AStar(start, end, ROW, COL, inputGrid); }).toThrowError('Error: Endpoint is unreachable');
     });
   });
+  describe('Completes grid successfully when no block', () => {
+    it('A*', () => {
+      const inputGrid = [
+        [1, 1, 1, 1, 1],
+        [1, 1, 1, 1, 1],
+        [1, 1, 1, 1, 1],
+        [1, 1, 1, 1, 1],
+        [1, 1, 1, 1, 1],
+      ];
+      const ROW = inputGrid.length;
+      const COL = inputGrid[0].length;
+      const start = {
+        i: 2,
+        j: 2,
+      };
+      const end1 = {
+        i: 0,
+        j: 0,
+      };
+      const completedPath1 = [[0, 0], [1, 1], [2, 2]];
+      expect(AStar(start, end1, ROW, COL, inputGrid)).toEqual(completedPath1);
+
+      const end2 = {
+        i: 0,
+        j: 2,
+      };
+      const completedPath2 = [[0, 2], [1, 2], [2, 2]];
+      expect(AStar(start, end2, ROW, COL, inputGrid)).toEqual(completedPath2);
+
+      const end3 = {
+        i: 0,
+        j: 4,
+      };
+      const completedPath3 = [[0, 4], [1, 3], [2, 2]];
+      expect(AStar(start, end3, ROW, COL, inputGrid)).toEqual(completedPath3);
+
+      const end4 = {
+        i: 2,
+        j: 4,
+      };
+      const completedPath4 = [[2, 4], [2, 3], [2, 2]];
+      expect(AStar(start, end4, ROW, COL, inputGrid)).toEqual(completedPath4);
+
+      const end5 = {
+        i: 4,
+        j: 4,
+      };
+      const completedPath5 = [[4, 4], [3, 3], [2, 2]];
+      expect(AStar(start, end5, ROW, COL, inputGrid)).toEqual(completedPath5);
+
+      const end6 = {
+        i: 4,
+        j: 2,
+      };
+      const completedPath6 = [[4, 2], [3, 2], [2, 2]];
+      expect(AStar(start, end6, ROW, COL, inputGrid)).toEqual(completedPath6);
+
+      const end7 = {
+        i: 4,
+        j: 0,
+      };
+      const completedPath7 = [[4, 0], [3, 1], [2, 2]];
+      expect(AStar(start, end7, ROW, COL, inputGrid)).toEqual(completedPath7);
+
+      const end8 = {
+        i: 2,
+        j: 0,
+      };
+      const completedPath8 = [[2, 0], [2, 1], [2, 2]];
+      expect(AStar(start, end8, ROW, COL, inputGrid)).toEqual(completedPath8);
+    });
+  });
 });

src/_PathFinder_/AStar/AStar.test.js

@@ -11,7 +11,10 @@ function AStar(s, e, row, col, inputGrid) {
   const end = e;
   const path = [];
 
-  if (end.i >= inputGrid.length || end.j >= inputGrid[0].length) {
+  const isValid = (i, j) => i >= 0 && j >= 0 && i < Row && j < Col;
+
+
+  if (!isValid(start.i, start.j) || !isValid(end.i, end.j)) {
     throw new Error('Error: Endpoint outside grid bounds');
   }
 
@@ -44,9 +47,6 @@ function AStar(s, e, row, col, inputGrid) {
     }
   }
 
-
-  const isValid = (i, j) => i >= 0 && j >= 0 && i < Row && j < Col;
-
   const isDestination = (i, j) => end.i === i && end.j === j;
 
   const isBlocked = (i, j) => grid[i][j].cellValue === 0;
@@ -124,10 +124,6 @@ function AStar(s, e, row, col, inputGrid) {
   };
 
   const search = () => {
-    if (!isValid(start.i, start.j) || !isValid(end.i, end.j)) {
-      return false;
-    }
-
     let i = start.i;
     let j = start.j;
     const openList = [];
@@ -185,36 +181,66 @@ function AStar(s, e, row, col, inputGrid) {
 
 
 // const inputGrid = [
-//   [1, 0, 1, 1, 1, 1, 0, 1, 1, 1],
-//   [1, 1, 1, 0, 1, 1, 1, 0, 1, 1],
-//   [1, 1, 1, 0, 1, 1, 0, 1, 0, 1],
-//   [0, 0, 1, 0, 1, 0, 0, 0, 0, 1],
-//   [1, 1, 1, 0, 1, 1, 1, 0, 1, 0],
-//   [1, 0, 1, 1, 1, 1, 0, 1, 0, 0],
-//   [1, 0, 0, 0, 0, 1, 0, 0, 0, 1],
-//   [1, 0, 1, 1, 1, 1, 0, 1, 1, 1],
-//   [1, 1, 1, 0, 0, 0, 1, 0, 0, 1],
+//   [1, 1, 1, 1, 1],
+//   [1, 1, 1, 1, 1],
+//   [1, 1, 1, 1, 1],
+//   [1, 1, 1, 1, 1],
+//   [1, 1, 1, 1, 1],
 // ];
+// const ROW = inputGrid.length;
+// const COL = inputGrid[0].length;
+// const start = {
+//   i: 2,
+//   j: 2,
+// };
+// const end1 = {
+//   i: 0,
+//   j: 0,
+// };
+// console.log(AStar(start, end1, ROW, COL, inputGrid));
+
+// const end2 = {
+//   i: 0,
+//   j: 2,
+// };
+// console.log(AStar(start, end2, ROW, COL, inputGrid));
+
+// const end3 = {
+//   i: 0,
+//   j: 4,
+// };
+// console.log(AStar(start, end3, ROW, COL, inputGrid));
+
+// const end4 = {
+//   i: 2,
+//   j: 4,
+// };
+// console.log(AStar(start, end4, ROW, COL, inputGrid));
+
+// const end5 = {
+//   i: 4,
+//   j: 4,
+// };
+// console.log(AStar(start, end5, ROW, COL, inputGrid));
+
+// const end6 = {
+//   i: 4,
+//   j: 2,
+// };
+// console.log(AStar(start, end6, ROW, COL, inputGrid));
+
+// const end7 = {
+//   i: 4,
+//   j: 0,
+// };
+// console.log(AStar(start, end7, ROW, COL, inputGrid));
+
+// const end8 = {
+//   i: 2,
+//   j: 0,
+// };
+// console.log(AStar(start, end8, ROW, COL, inputGrid));
 
-const inputGrid = [
-  [1, 0, 0, 0, 0, 0],
-  [1, 1, 1, 1, 1, 1],
-  [1, 0, 0, 0, 0, 0],
-  [1, 1, 1, 1, 1, 1],
-];
-
-const ROW = inputGrid.length;
-const COL = inputGrid[0].length;
-const start = {
-  i: 0,
-  j: 0,
-};
-const end = {
-  i: 3,
-  j: 5,
-};
-
-AStar(start, end, ROW, COL, inputGrid);
 
 
 module.exports = {

src/_PathFinder_/AStar/index.js

@@ -75,5 +75,14 @@ describe('Anagrams', () => {
         }),
       ).toBe(true);
     });
+
+    it('Should return FALSE for `Hello` & `Hallo`', () => {
+      expect(
+        checkAnagrams({
+          firstString: 'Hello',
+          secondString: 'Hallo',
+        }),
+      ).toBe(false);
+    });
   });
 });

src/_Problems_/anagrams/anagrams.test.js

@@ -22,6 +22,13 @@ describe('Get common smallest number between two integer arrays', () => {
     expect(getSmallestCommonNumber(arr1, arr2)).toEqual(-10);
   });
 
+  it('Should return common smallest number between unsorted two integer arrays', () => {
+    const arr1 = [-10, 3, -11];
+    const arr2 = [-11, 2, -10, 7];
+
+    expect(getSmallestCommonNumber(arr1, arr2)).toEqual(-11);
+  });
+
   it('Should return common smallest number between sorted two integer arrays', () => {
     const arr1 = [2, 3];
     const arr2 = [2, 5, 7];

src/_Problems_/get-smallest-common-number/get-smallest-common-number.test.js

@@ -1,7 +1,7 @@
 // Get the common smallest number between two integer arrays
 
 const getSmallestCommonNumber = (a1, a2) => {
-  let map = {};
+  const map = {};
   let i = 0;
   let min;
 
@@ -20,7 +20,7 @@ const getSmallestCommonNumber = (a1, a2) => {
       }
     }
 
-    i++;
+    i += 1;
   }
 
   return min || -1;

src/_Problems_/get-smallest-common-number/index.js

@@ -1,20 +1,30 @@
-const { jumpSearch, jumpSearchRecursive } = require('.');
+const { jumpSearch } = require('.');
 
-describe('Jump Search', () => {
-    const array = [1, 2, 3, 4, 5, 6, 7, 8];
-    describe('When element to find is at 1st position ', () => {
-        it('Jump search', () => {
-          expect(jumpSearch(array, 1)).toEqual(0);
-        });
-      });
-    describe('When element to find is at last position ', () => {
-        it('Jump search', () => {
-          expect(jumpSearch(array, 7)).toEqual(6);
-        });
-      });
-    describe('When element to find is at random position ', () => {
-        it('Jump search', () => {
-          expect(jumpSearch(array, 3)).toEqual(2);
-        });
-      });
-});
+describe('Jump Search', () => {
+  const array = [1, 2, 3, 4, 5, 6, 7, 8, 20];
+  describe('When element to find is at 1st position ', () => {
+    it('Jump search', () => {
+      expect(jumpSearch(array, 1)).toEqual(0);
+    });
+  });
+  describe('When element to find is at last position ', () => {
+    it('Jump search', () => {
+      expect(jumpSearch(array, 20)).toEqual(8);
+    });
+  });
+  describe('When element to find is at random position ', () => {
+    it('Jump search', () => {
+      expect(jumpSearch(array, 3)).toEqual(2);
+      expect(jumpSearch(array, 5)).toEqual(4);
+      expect(jumpSearch(array, 6)).toEqual(5);
+      expect(jumpSearch(array, 8)).toEqual(7);
+    });
+  });
+  describe('When element is not in array ', () => {
+    it('Jump search', () => {
+      expect(jumpSearch(array, 15)).toEqual(-1);
+      expect(jumpSearch(array, 25)).toEqual(-1);
+      expect(jumpSearch(array, 9)).toEqual(-1);
+    });
+  });
+});

src/_Searching_/JumpSearch/JumpSearch.test.js

@@ -1,38 +1,32 @@
 /**
  * Note: Array must be sorted for jump search
- * Complexity: 
+ * Complexity:
  * Worst case time complexity: O(√N)
  * Average case time complexity: O(√N)
  * Best case time complexity: O(1)
  * Space complexity: O(1)
 */
 function jumpSearch(arr, key) {
-    const n = arr.length;
-    const jump = Math.floor(Math.sqrt(n));
-    let step = jump;
+  const n = arr.length;
+  const jump = Math.floor(Math.sqrt(n));
+  let step = jump;
+  let prev = 0;
 
-    let prev = 0;
-    
-    while(arr[Math.min(step, n) - 1] < key) {
-        prev = step;
-        step += jump;
-        if (prev >= n) 
-            return null; 
-    }
+  while (arr[Math.min(step, n) - 1] < key) {
+    prev = step;
+    step += jump;
+    if (prev >= n) { return -1; }
+  }
+
+  while (arr[prev] < key && prev < Math.min(step, n)) {
+    prev += 1;
+  }
 
-    while(arr[prev] < key) {
-        prev++;
+  if (arr[prev] === key) { return prev; }
 
-        if (prev == Math.min(step, n))
-            return null;
-    }
-    
-    if (arr[prev] == key) 
-        return prev; 
+  return -1;
+}
 
-    return null;
-  }
-  
-  module.exports = {
-    jumpSearch,
-  };
+module.exports = {
+  jumpSearch,
+};

src/_Searching_/JumpSearch/index.js

@@ -24,10 +24,14 @@ describe('Ternary Search', () => {
   describe('When element to find is at random position ', () => {
     it('Ternary search with Loop', () => {
       expect(ternarySearch(array, 3)).toEqual(2);
+      expect(ternarySearch(array, 5)).toEqual(4);
     });
     it('Ternary serach with recursion', () => {
       expect(ternarySearchRecursive(array, low, high, 4)).toEqual(3);
     });
+    it('Ternary serach with recursion', () => {
+      expect(ternarySearchRecursive(array, low, high, 5)).toEqual(4);
+    });
   });
   describe('When element to find is no present in array ', () => {
     it('Ternary search with Loop', () => {
@@ -37,5 +41,4 @@ describe('Ternary Search', () => {
       expect(ternarySearchRecursive(array, low, high, 10)).toEqual(null);
     });
   });
-  
 });

src/_Searching_/TernarySearch/TernarySearch.test.js

@@ -1,53 +1,52 @@
 /**
  * Note: Array must be sorted for ternary search
- * Complexity: 
+ * Complexity:
  * Worst case time complexity: O(log N)
  * Average case time complexity: O(log N)
  * Best case time complexity: O(1)
  * Space complexity: O(1)
 */
-function ternarySearch(arr, key){
-    let low = 0;
-    let high = arr.length - 1;
-    while(low <= high){
-        let lowMiddle = low + Math.floor((high - low) / 3);
-        let highMiddle = low + 2 * Math.floor((high - low) / 3);
-        if(key == arr[low]){
-            return low;
-        } else if(key  == arr[high]){
-            return high;
-        } else if(key <= arr[lowMiddle]){
-            high = lowMiddle;
-        } else if(key > arr[lowMiddle] && key <= arr[highMiddle]){
-            low = lowMiddle + 1;
-            high = highMiddle;
-        } else {
-            low = highMiddle + 1;
-        }
+function ternarySearch(arr, key) {
+  let low = 0;
+  let high = arr.length - 1;
+  while (low <= high) {
+    const lowMiddle = low + Math.floor((high - low) / 3);
+    const highMiddle = low + 2 * Math.floor((high - low) / 3);
+    if (key === arr[low]) {
+      return low;
+    } if (key === arr[high]) {
+      return high;
+    } if (key <= arr[lowMiddle]) {
+      high = lowMiddle;
+    } else if (key > arr[lowMiddle] && key <= arr[highMiddle]) {
+      low = lowMiddle + 1;
+      high = highMiddle;
+    } else {
+      low = highMiddle + 1;
     }
-    return null;
+  }
+  return null;
 }
 
-function ternarySearchRecursive(arr, low, high, key){
-    if(high >= low){
-        let highMiddle = low + 2 * Math.floor((high - low) / 3);
-        let lowMiddle = low + Math.floor((high - low) / 3);
-        if(key === arr[lowMiddle]){
-            return lowMiddle;
-        } else if(key === arr[highMiddle]){
-            return highMiddle;
-        } else if(key < arr[lowMiddle]){
-            return ternarySearchRecursive(arr, low, lowMiddle - 1, key);
-        } else if(key > arr[lowMiddle] && key < arr[highMiddle]){
-            return ternarySearchRecursive(arr, lowMiddle + 1, highMiddle - 1, key);
-        } else {
-            return ternarySearchRecursive(arr, highMiddle + 1, high, key);
-        } 
-    } 
-    return null;
+function ternarySearchRecursive(arr, low, high, key) {
+  if (high >= low) {
+    const highMiddle = low + 2 * Math.floor((high - low) / 3);
+    const lowMiddle = low + Math.floor((high - low) / 3);
+    if (key === arr[lowMiddle]) {
+      return lowMiddle;
+    } if (key === arr[highMiddle]) {
+      return highMiddle;
+    } if (key < arr[lowMiddle]) {
+      return ternarySearchRecursive(arr, low, lowMiddle - 1, key);
+    } if (key > arr[lowMiddle] && key < arr[highMiddle]) {
+      return ternarySearchRecursive(arr, lowMiddle + 1, highMiddle - 1, key);
+    }
+    return ternarySearchRecursive(arr, highMiddle + 1, high, key);
+  }
+  return null;
 }
 
 module.exports = {
-    ternarySearch,
-    ternarySearchRecursive
+  ternarySearch,
+  ternarySearchRecursive,
 };