--fix : unit test title & use loops to create BST

Author: TheSTL

src/_DataStructures_/DoublyLinkedList/doublyLinkedList.test.js

@@ -1,36 +1,40 @@
 const DLL = require('.');
 
 describe('Doubly Linked List', () => {
+  it('Should be class', () => {
+    expect(typeof DLL.prototype.constructor).toEqual('function');
+  });
+
   const doublyLinkedList = new DLL();
 
-  it('create 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('addAtBeginning', () => {
+  it('It should add at beginning (addAtBeginning)', () => {
     doublyLinkedList.addAtBeginning(1);
     doublyLinkedList.addAtBeginning(2);
     doublyLinkedList.addAtBeginning(3);
     expect(doublyLinkedList.traverse()).toEqual([3, 2, 1]);
   });
 
-  it('addAtEnd', () => {
+  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('removeAtBeginning', () => {
+  it('It should remove at beginning (removeAtBeginning)', () => {
+    doublyLinkedList.removeAtBeginning();
     doublyLinkedList.removeAtBeginning();
     doublyLinkedList.removeAtBeginning();
-    doublyLinkedList.removeAtBeginning();    
     expect(doublyLinkedList.traverse()).toEqual([1, 2, 3]);
   });
 
-  it('removeAtEnd', () => {
+  it('It should remove at end (removeAtEnd)', () => {
     doublyLinkedList.removeAtEnd();
     doublyLinkedList.removeAtEnd();
     doublyLinkedList.removeAtEnd();

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');
   });
 
@@ -56,7 +56,7 @@ describe('Data Structure : Queue', () => {
       expect(queue.dequeue()).toEqual(null);
     });
 
-    it('Length of linkedlist', () => {
+    it('Shoud return size of Queue', () => {
       const queue2 = new Queue();
       queue2.enqueue(2);
       queue2.enqueue(1);
@@ -65,7 +65,7 @@ describe('Data Structure : Queue', () => {
       expect(queue2.length()).toEqual(4);
     });
 
-    it('Destroy linkedList', () => {
+    it('Should Destroy Queue', () => {
       queue.destroy();
       expect(queue.length()).toEqual(0);
     });

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

@@ -3,25 +3,15 @@ const BinarySearchTree = require('./index');
 describe('Binary Search Tree', () => {
   describe('Is Empty', () => {
     const bst = new BinarySearchTree(6);
-    bst.add(4);
-    bst.add(9);
-    bst.add(2);
-    bst.add(5);
-    bst.add(8);
-    bst.add(12);
-    it('should return False', () => {
+    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', () => {
-      bst.remove(6);
-      bst.remove(4);
-      bst.remove(9);
-      bst.remove(2);
-      bst.remove(5);
-      bst.remove(8);
-      bst.remove(12);
-      
+    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-maximum.test.js

@@ -3,17 +3,14 @@ const BinarySearchTree = require('./index');
 describe('Binary Search Tree', () => {
   describe('Find maximum value in BST', () => {
     const bst = new BinarySearchTree(6);
-    bst.add(4);
-    bst.add(9);
-    bst.add(2);
-    bst.add(5);
-    bst.add(8);
-    bst.add(12);
-    it('should return 12', () => {
+    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('should return 20', () => {
+    it('It should expect new maximum key added in BST', () => {
       bst.add(20);
       expect(bst.getMaximum()).toEqual(20);
     });

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

@@ -1,19 +1,16 @@
 const BinarySearchTree = require('./index');
 
 describe('Binary Search Tree', () => {
-  describe('Find minimum value in BST', () => {
+  describe('It should Find the minimum value in BST', () => {
     const bst = new BinarySearchTree(6);
-    bst.add(4);
-    bst.add(9);
-    bst.add(2);
-    bst.add(5);
-    bst.add(8);
-    bst.add(12);
-    it('should return 4', () => {      
+    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('should return 1', () => {
+    it('It should expect new minimum key added to BST', () => {
       bst.add(1);
       expect(bst.getMinimum()).toEqual(1);
     });

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

@@ -1,7 +1,7 @@
 const BST = require('.');
 
 describe('Data Structure : Binary Search Tree', () => {
-  it('Should be class', () => {
+  it('Binary Search Tree should be a Class', () => {
     expect(typeof BST.prototype.constructor).toEqual('function');
   });
 

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

@@ -1,20 +1,16 @@
 const BinarySearchTree = require('./index');
 
 describe('Binary Search Tree', () => {
-  describe('Find maximum value in BST', () => {
+  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));
 
-    bst.add(4);
-    bst.add(9);
-    bst.add(2);
-    bst.add(5);
-    bst.add(8);
-    bst.add(12);
-    it('search for 8', () => {
+    it('It should return true for 8', () => {
       expect(bst.searchFor(8)).toEqual(true);
     });
 
-    it('search for 100', () => {
+    it('It should return false for 100', () => {
       expect(bst.searchFor(100)).toEqual(false);
     });
   });

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

@@ -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));
     });
   });
 
@@ -49,18 +45,12 @@ describe('Binary search tree traversals', () => {
     });
   });
 
-  describe('Check bst was created as expected', () => {
+  describe('When root left subtree height is greater than right', () => {
     const bst2 = new BinarySearchTree(10);
-    bst2.add(11);
-    bst2.add(20);
-    bst2.add(9);
-    bst2.add(8);
-    bst2.add(7);
-    bst2.add(6);
-    bst2.add(5);
-    bst2.add(4);
+    const keys = [11, 20, 9, 8, 7, 6, 5, 4];
+    keys.forEach(el => bst2.add(el));
 
-    it('Height should be 7', () => {
+    it('should return height of BST ', () => {
       expect(heightOfBST(bst2.root)).toEqual(7);
     });
   });

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

@@ -4,18 +4,18 @@
  * 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.test.js

@@ -4,31 +4,21 @@ 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);
-  bst.add(22);
-  bst.add(8);
-  bst.add(12);
-  bst.add(4);
-  bst.add(14);
-  bst.add(10);
+  const keys = [22, 8, 12, 4, 14, 10];
+  keys.forEach(el => bst.add(el));
 
-  it('Should return 12', () => {
+  it('Should return Lowest Common Ancestor Node ', () => {
     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 20', () => {
     expect(lca(bst.root, 10, 22).value).toEqual(20);
   });
 
   const bst2 = new BinarySearchTree(6);
   bst2.remove(6);
 
-  it('Should return Null', () => {
+  it('Should return Null when root is null', () => {
     expect(lca(bst2.root, 10, 22)).toEqual(null);
   });
 });