Replace checkBalanced function with depthFirstForEach and breadthFirstForEach exercises

Author: seanchen1991

README.md

@@ -1,24 +1,27 @@
 # Sprint Challenge: Data Structures and Algorithms
 
-For this sprint challenge, you'll be implementing a few functions that build off of some of the data structures you implemented in the first half of the week. Then you'll be analyzing the runtimes of these methods. 
+For this sprint challenge, you'll be implementing a few functions that build off of some of the data structures you implemented in the first half of the week. Then you'll be analyzing the runtimes of all of the data structure methods. 
 
 For the algorithms portion of the sprint challenge, you'll be answering the questions posed in the `exercises.pdf` file regarding runtime complexities and algorithmic paradigms.
 
 ## Data Structures
 Before getting started, run `npm install` in the root-level directory to install needed dependencies for testing.
 
-### Task 1. Implement Heapsort
-Inside the `src` directory you'll also find the `heap.js` file with the completed code the heap class. Your second task is to implement a sorting method called [heapsort](https://en.wikipedia.org/wiki/Heapsort) that uses the heap data structure in order to sort an array of numbers. Your `heapsort` function should return a new array containing all of the sorted data.
-
-Run `npm test heap` to run the tests for your `heapsort` function to ensure that your implementation is correct.
+### Task 1. Implement Depth-First and Breadth-First Traversal on the Binary Search Tree Class 
+Navigate into the `data_structures` directory. Inside the `src` directory, you'll see the `binary-search-tree.js` file with the completed code for the binary search tree class. Your first task is to implement the methods `depthFirstForEach` and `breadthFirstForEach` on the `BinarySearchTree` class:
 
-### Task 2. Check if a binary search tree is balanced
-Navigate into the `data_structures` directory. Inside the `src` directory, you'll see the `binary-search-tree.js` file with the completed code for the binary search tree class. Your first task is to write a separate function (not part of the `BinarySearchTree` class) that receives the root node of an instance of a binary search tree and returns `true` if the binary search tree is perfectly balanced, i.e., all the leaf nodes of the tree reside on the same level. Your function should return `false` if the tree is not perfectly balanced.
+   * `depthFirstForEach(cb)` receives a callback function as a parameter. This method iterates over the binary search tree in [depth-first](https://en.wikipedia.org/wiki/Depth-first_search) order, applying the supplied callback function to each tree element in turn. 
+   * `breadthFirstForEach(cb)` receives a callback function as a parameter. This method iterates over the binary search tree in [breadth-first](https://en.wikipedia.org/wiki/Breadth-first_search) order, applying the supplied callback function to each tree element in turn.
 
 Run `npm test binary-search-tree` to run the tests for this function to ensure that your implementation is correct.
 
+### Task 2. Implement Heapsort
+Inside the `src` directory you'll also find the `heap.js` file with the completed code the heap class. Your second task is to implement a sorting method called [heapsort](https://en.wikipedia.org/wiki/Heapsort) that uses the heap data structure in order to sort an array of numbers. Your `heapsort` function should return a new array containing all of the sorted data.
+
+Run `npm test heap` to run the tests for your `heapsort` function to ensure that your implementation is correct.
+
 ### Task 3. Analyze some runtimes
-Open up the `Data_Structures_Questions.md` file. This is where you'll jot down your answers for the runtimes of the two functions you just implemented.
+Open up the `Data_Structures_Answers.md` file. This is where you'll jot down your answers for the runtimes of the functions you just implemented. Be sure to also answer any other questions posed in the `Answers.md` file!
 
 ## Algorithms
 For the algorithms portion of the sprint challenge, you'll be answering questions posed in the `exercises.pdf` document inside the `algorithms` directory. Add your answers to the questions in the `Algorithms_Answers.md` file.

data_structures/Data_Structures_Questions.md

@@ -1,9 +1,13 @@
 Add your answers to the questions below.
 
-1. What is the runtime complexity of your `checkBalanced` function?
+1. What is the runtime complexity of your `depthFirstForEach` method?
 
-2. What is the space complexity of your `checkBalanced` function?
+2. What is the space complexity of your `depthFirstForEach` function?
 
-3. What is the runtime complexity of your `heapsort` function?
+3. What is the runtime complexity of your `breadthFirstForEach` method?
 
-4. What is the space complexity of the `heapsort` function? Recall that your implementation should return a new array with the sorted data. What would be the space complexity if your function instead altered the input array?
+4. What is the space complexity of your `breadthFirstForEach` method? 
+
+5. What is the runtime complexity of your `heapsort` function?
+
+6. What is the space complexity of the `heapsort` function? Recall that your implementation should return a new array with the sorted data. What would be the space complexity if your function instead altered the input array?

data_structures/src/binary-search-tree.js

@@ -1,15 +1,20 @@
-const checkBalanced = (rootNode) => {
-  /* Your code here */
-
-};
-
 class BinarySearchTree {
   constructor(value) {
     this.value = value;
     this.left = null;
     this.right = null;
   }
 
+  depthFirstForEach(cb) {
+    /* Your code here */
+    
+  }
+
+  breadthFirstForEach(cb) {
+    /* Your code here */
+
+  }
+
   insert(value) {
     const newNode = new BinarySearchTree(value);
     if (value < this.value) {
@@ -59,19 +64,6 @@ class BinarySearchTree {
 
     return max;
   }
-
-  depthFirstForEach(cb) {
-    cb(this.value);
-    if (this.left) {
-      this.left.depthFirstForEach(cb);
-    }
-    if (this.right) {
-      this.right.depthFirstForEach(cb);
-    }
-  }
 }
 
-module.exports = {
-  BinarySearchTree,
-  checkBalanced,
-};
+module.exports = BinarySearchTree;

data_structures/tests/binary-search-tree.test.js

@@ -1,27 +1,36 @@
-const { BinarySearchTree, checkBalanced } = require('../src/binary-search-tree');
+const BinarySearchTree = require('../src/binary-search-tree');
 
 let bst;
 
-describe('checkBalanced', () => {
+describe('`depthFirstForEach` and `breadthFirstForEach`', () => {
   beforeEach(() => {
-    bst = new BinarySearchTree(10);
+    bst = new BinarySearchTree(5);
   });
 
-  test('checkBalanced returns true given a perfectly balanced tree', () => {
-    expect(checkBalanced(bst)).toBe(true);
+  test("`depthFirstForEach` executes a callback on every value in a tree in depth-first order", () => {
+    const array = [];
+    const cb = x => array.push(x);
 
-    bst.insert(11);
+    bst.insert(2);
+    bst.insert(3);
+    bst.insert(7);
     bst.insert(9);
+    bst.depthFirstForEach(cb);
 
-    expect(checkBalanced(bst)).toBe(true);
+    expect(array).toEqual([5, 2, 3, 7, 9]);
   });
 
-  test('checkBalanced returns false given a tree that is not perfectly balanced', () => {
-    bst.insert(11);
-    bst.insert(12);
-    expect(checkBalanced(bst)).toBe(false);
+  test("`breadthFirstForEach` executes a callback on every value in a tree in breadth-first order", () => {
+    const array = [];
+    const cb = x => array.push(x);
 
+    bst.insert(3);
+    bst.insert(4);
+    bst.insert(10);
     bst.insert(9);
-    expect(checkBalanced(bst)).toBe(false);
+    bst.insert(11);
+    bst.breadthFirstForEach(cb);
+
+    expect(array).toEqual([5, 3, 10, 4, 9, 11]);
   });
 });