Implemented BFS (#11 IP)

Author: CoffeelessProgrammer

Algorithms/README.md

@@ -20,6 +20,9 @@
 - [Unicode Characters | RapidTables](https://www.rapidtables.com/code/text/unicode-characters.html)
 - [The Big-O Algorithm Complexity Cheat Sheet](https://www.bigocheatsheet.com/ "Big O Cheat Sheet")
 
+### Searching
+- [Space Complexity: BFS vs DFS](https://stackoverflow.com/questions/9844193/what-is-the-time-and-space-complexity-of-a-breadth-first-and-depth-first-tree-tr)
+
 ### Sorting
 - [Array.prototype.sort()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)
 - [Animated Sorting | Toptal](https://www.toptal.com/developers/sorting-algorithms)

Algorithms/Recursion/BreadthFirstSearch.ts

@@ -0,0 +1,58 @@
+import BST from '../../Data-Structures/Trees/BinarySearchTree.ts';
+import Node from '../../Data-Structures/Trees/BinaryTreeNode.ts';
+import Queue from '../../Data-Structures/Sequential/Queue.ts';
+
+function recursiveBFS(nodeQueue: Queue<Node>, nodesTraversed: Array<number>): Array<number> {
+  if (nodeQueue.getLength() === 0) return nodesTraversed;
+
+  let currentNode: Node = nodeQueue.dequeue();
+  nodesTraversed.push(currentNode.getValue());
+  if (currentNode.hasLeft()) nodeQueue.enqueue(currentNode.getLeft());
+  if (currentNode.hasRight()) nodeQueue.enqueue(currentNode.getRight());
+
+  return recursiveBFS(nodeQueue, nodesTraversed);
+}
+
+function breadthFirstSearch(tree: BST) {
+  const root = tree.getRoot();
+
+  if (!root) return false;
+
+  const nodesTraversed: number[] = [];
+  const nodeQueue = new Queue<Node>();
+
+  nodeQueue.enqueue(root);
+
+  return recursiveBFS(nodeQueue, nodesTraversed);
+}
+
+
+//---------------------------------------------------------------------
+// ----------                 MAIN PROGRAM                   ----------
+//---------------------------------------------------------------------
+if (import.meta.main) {
+
+  const tree = new BST();
+
+  //        9
+  //    4       20
+  //  1   6   15  170
+
+  tree.insert(9);
+  tree.insert(4);
+  tree.insert(6);
+  tree.insert(20);
+  tree.insert(170);
+  tree.insert(15);
+  tree.insert(1);
+
+  console.log(breadthFirstSearch(tree));
+
+  // RUN:   deno run Algorithms/Recursion/BreadthFirstSearch.ts
+}
+
+// --------------------------- Terminal Output: ---------------------------
+// [
+//   9, 4, 20, 1,
+//   6, 15, 170
+// ]

Algorithms/Searching/Basics.ts

@@ -0,0 +1,13 @@
+var beasts = ['Centaur', 'Godzilla', 'Mosura', 'Minotaur', 'Hydra', 'Nessie'];
+
+beasts.indexOf('Godzilla');           // Index: 1
+
+beasts.findIndex(function(item){      // Index: 1
+  return item === 'Godzilla';
+});
+
+beasts.find(function(item){           // 'Godzilla'
+  return item === 'Godzilla';
+});
+
+beasts.includes('Godzilla');          //  true

Algorithms/Searching/Exercise_BFSDFSUseCases.md

@@ -0,0 +1,23 @@
+# Graph Traversal Use Cases
+
+## Which traversal algorithm would be best for each situation? (BFS or DFS)
+
+1) If you know a solution is not far from the root of the tree:
+
+2) If the tree is very deep and solutions are rare, 
+
+3) If the tree is very wide:
+
+4) If solutions are frequent but located deep in the tree
+
+5) determining whether a path exists between two nodes
+
+6) Finding the shortest path
+
+## Answers
+1) BFS
+2) BFS (DFS will take longer)
+3) DFS (BFS is too memory intensive for wide trees)
+4) DFS
+5) DFS
+6) BFS

Algorithms/Sorting/SortingUseCases_Exercise.md renamed to Algorithms/Sorting/Exercise_SortingUseCases.md

@@ -1,37 +1,51 @@
-import LinkedList from '../../Data-Structures/Linked-Lists/LinkedList.ts';
 import { plant_families } from './Data/PlantFamilies.ts';
 
+function insertionSort(inputArr: number[] | string[]) {
 
-function insertionSort(inputArr: number[] | string[]): Array<any> {
-  const sorted = new LinkedList<any>();
-
-  sorted.append(inputArr[0]);
-
-  for (let i=1; i < inputArr.length; ++i) {
-
-    let currentElement = inputArr[i];
-    let currentNode = sorted.getHead();
-
-    // Element is less than the lowest value
-    if (currentElement < sorted.getHeadValue()) {
-      sorted.prepend(currentElement);
-    }
-    // Element is greater than the highest value
-    else if (currentElement > sorted.getTailValue()) {
-      sorted.append(currentElement)
+  if (typeof inputArr[0] === 'number') {
+    for (let i=0; i < inputArr.length; ++i) {
+      if (inputArr[i] < inputArr[0]) {
+        const element = inputArr.splice(i,1) as number[];
+        //  Move element to the first position
+        (inputArr as number[]).unshift(element[0]);
+      }
+      else {
+        // Only sort number smaller than preceding number
+        if (inputArr[i] < inputArr[i-1]) {
+          //  Find where element's sorted position
+          for (var j = 1; j < i; j++) {
+            if (inputArr[i] >= inputArr[j-1] && inputArr[i] < inputArr[j]) {
+              // Move element to the sorted spot
+              inputArr.splice(j,0,inputArr.splice(i,1)[0] as number);
+            }
+          }
+        }
+      }
     }
-    // Otherwise insert in its proper, sorted position
-    else {
-      for (let j=0; j < sorted.getLength()-1; ++j) {
-        if (currentNode.getValue() < currentElement && currentNode.getNext().getValue() > currentElement) {
-          sorted.insert(currentElement, j+1);
-          break;
+  }
+  else if (typeof inputArr[0] === 'string') {
+    for (let i=0; i < inputArr.length; ++i) {
+      if (inputArr[i] < inputArr[0]) {
+        const element = inputArr.splice(i,1) as string[];
+        //  Move element to the first position
+        (inputArr as string[]).unshift(element[0]);
+      }
+      else {
+        // Only sort number smaller than preceding number
+        if (inputArr[i] < inputArr[i-1]) {
+          //  Find where element's sorted position
+          for (var j = 1; j < i; j++) {
+            if (inputArr[i] >= inputArr[j-1] && inputArr[i] < inputArr[j]) {
+              // Move element to the sorted spot
+              inputArr.splice(j,0,inputArr.splice(i,1)[0] as string);
+            }
+          }
         }
-        currentNode = currentNode.getNext();
       }
     }
   }
-  return sorted.toArray();
+
+  return inputArr;
 }
 
 function executionTime(method: any): string {

Algorithms/Sorting/InsertionSort.ts

@@ -15,10 +15,6 @@ export default class LinkedList<T> {
     return this.length;
   }
 
-  public getHead(): Node<T> | any {
-    return this.head;
-  }
-
   public getHeadValue(): T | any {
     return this.head?.getValue();
   }

Data-Structures/Linked-Lists/LinkedList.ts

@@ -40,7 +40,7 @@ export default class Queue<T> {
     return true;
   }
 
-  public dequeue(): T | null {
+  public dequeue(): T | any {
     if (!this.first) return null;             // Edge case: Empty queue
 
     if (this.length === 1) {                  // Edge case: Queue has 1 element, so a dequeue should reset the queue's state

Data-Structures/Sequential/Queue.ts

@@ -1,4 +1,5 @@
 import BNode from './BinaryTreeNode.ts';
+import Queue from '../Sequential/Queue.ts';
 
 
 export default class BinarySearchTree {
@@ -205,6 +206,24 @@ export default class BinarySearchTree {
     node.setRight(left);
   }
 
+  public breadthFirstSearch() {
+    if (!this.root) return false;
+
+    let currentNode = this.root;
+    let nodesTraversed = new Array();
+    const nodeQueue: Queue<BNode> = new Queue();
+
+    nodeQueue.enqueue(currentNode);
+
+    while (nodeQueue.getLength() > 0) {
+      currentNode = nodeQueue.dequeue();
+      nodesTraversed.push(currentNode.getValue());
+      if (currentNode.hasLeft()) nodeQueue.enqueue(currentNode.getLeft());
+      if (currentNode.hasRight()) nodeQueue.enqueue(currentNode.getRight());
+    }
+    return nodesTraversed;
+  }
+
   public equalsQuantum(tree: BinarySearchTree): boolean {
     return JSON.stringify(this) === JSON.stringify(tree);
   }
@@ -233,7 +252,8 @@ if (import.meta.main) {
   tree.insert(170);
   tree.insert(15);
   tree.insert(1);
-  console.log('Tree: ', JSON.stringify(BinarySearchTree.traverse(tree.getRoot())));
+  console.log(tree.breadthFirstSearch());
+  // console.log('Tree: ', JSON.stringify(BinarySearchTree.traverse(tree.getRoot())));
   tree.remove(20);
   printNode(tree, 4);
   printNode(tree, 17);
@@ -243,14 +263,21 @@ if (import.meta.main) {
   tree.invertTree();
   console.log('Inverse Tree: ', JSON.stringify(BinarySearchTree.traverse(tree.getRoot())));
 
+  console.log(tree.breadthFirstSearch());
+
   // RUN: deno run Data-Structures/Trees/BinarySearchTree.ts
 }
 
 // --------------------------- Terminal Output: ---------------------------
+// [
+//   9, 4, 20, 1,
+//   6, 15, 170
+// ]
 // Tree:  {"value":9,"left":{"value":4,"left":{"value":1,"left":null,"right":null},"right":{"value":6,"left":null,"right":null}},"right":{"value":20,"left":{"value":15,"left":null,"right":null},"right":{"value":170,"left":null,"right":null}}}
 // Find 4: {"value":4,"left":{"value":1,"left":null,"right":null},"right":{"value":6,"left":null,"right":null}}
 // Find 17: Node not found.
 // Find 40: Node not found.
 // Find 170: {"value":170,"left":{"value":15,"left":null,"right":null},"right":null}
 // Original Tree:  {"value":9,"left":{"value":4,"left":{"value":1,"left":null,"right":null},"right":{"value":6,"left":null,"right":null}},"right":{"value":170,"left":{"value":15,"left":null,"right":null},"right":null}}
-// Inverse Tree:  {"value":9,"left":{"value":170,"left":null,"right":{"value":15,"left":null,"right":null}},"right":{"value":4,"left":{"value":6,"left":null,"right":null},"right":{"value":1,"left":null,"right":null}}}
+// Inverse Tree:  {"value":9,"left":{"value":170,"left":null,"right":{"value":15,"left":null,"right":null}},"right":{"value":4,"left":{"value":6,"left":null,"right":null},"right":{"value":1,"left":null,"right":null}}}
+// [ 9, 170, 4, 15, 6, 1 ]

Data-Structures/Trees/BinarySearchTree.ts

@@ -32,4 +32,14 @@ export default class BinaryTreeNode {
   public getRight(): BinaryTreeNode | any {
     return this.right;
   }
+
+  public hasLeft(): boolean {
+    if (!!this.left) return true;
+    return false;
+  }
+
+  public hasRight(): boolean {
+    if (!!this.right) return true;
+    return false;
+  }
 }