Implement new solutions.

Author: Andre Stackhouse

data-structures/TreeNode.js

@@ -43,6 +43,21 @@ const TreeNode = (data) => {
         }
       }
       console.log(feedback_string);
+    },
+    depthFirstSearch: function(target_node) {
+      if (this === target_node) {
+        return this;
+      } else {
+        let left_search = this.left ? this.left.depthFirstSearch(target_node) : -1;
+        let right_search = this.right ? this.right.depthFirstSearch(target_node) : -1;
+        if (left_search !== -1) {
+          return left_search;
+        } else if (right_search !== -1) {
+          return right_search;
+        } else {
+          return -1;
+        }
+      }
     }
   }
 }

index.html

@@ -171,12 +171,15 @@ <h3>Mocha Test Output</h3>
     <script src="solutions/04-trees-and-graphs/04-02-minimal_tree.js"></script>
     <script src="solutions/04-trees-and-graphs/04-03-list_of_depths.js"></script>
     <script src="solutions/04-trees-and-graphs/04-04-check_balanced.js"></script>
+    <script src="solutions/04-trees-and-graphs/04-08-first_common_ancestor.js"></script>
     <script src="solutions/04-trees-and-graphs/is_binary_search_tree.js"></script>
 
     <!-- Recursion and Dynamic Programming -->
     <script src="solutions/08-recursion-and-dynamic-programming/08-01-triple_step.js"></script>
     <script src="solutions/08-recursion-and-dynamic-programming/08-03-magic_index.js"></script>
+    <script src="solutions/08-recursion-and-dynamic-programming/08-04-power_set.js"></script>
     <script src="solutions/08-recursion-and-dynamic-programming/08-05-recursive_multiply.js"></script>
+    <script src="solutions/08-recursion-and-dynamic-programming/max_nonadjacent_subset.js"></script>
 
     <!-- Sorting and Searching -->
     <script src="solutions/10-sorting-and-searching/10-01-sorted_merge.js"></script>

object-instances/sample_trees.js

@@ -7,15 +7,18 @@ valid_bst.left = TreeNode(5);
 valid_bst.right = TreeNode(11);
 
 valid_bst.left.left = TreeNode(2);
-valid_bst.left.right = TreeNode(7);
+let shallow_left = TreeNode(7);
+valid_bst.left.right = shallow_left;
 
 valid_bst.left.left.right = TreeNode(4);
-valid_bst.left.left.right.left = TreeNode(3);
+let far_left_node = TreeNode(3);
+valid_bst.left.left.right.left = far_left_node;
 
 valid_bst.right.left = TreeNode(10);
 valid_bst.right.right = TreeNode(18);
 
-valid_bst.right.right.right = TreeNode(20);
+let close_to_bottom = TreeNode(20);
+valid_bst.right.right.right = close_to_bottom;
 
 // Invalid BST
 let invalid_bst = TreeNode(8);

solutions/04-trees-and-graphs/04-08-first_common_ancestor.js

@@ -0,0 +1,12 @@
+function first_common_ancestor(root, target_1, target_2) {
+  let helper = (current) => {
+    if (current.left && current.left.depthFirstSearch(target_1) !== -1 && current.left.depthFirstSearch(target_2) !== -1) {
+      return helper(current.left);
+    } else if (current.right && current.right.depthFirstSearch(target_1) !== -1 && current.right.depthFirstSearch(target_2) !== -1) {
+      return helper(current.right);
+    } else {
+      return current;
+    }
+  }
+  return helper(root);
+}

solutions/08-recursion-and-dynamic-programming/08-04-power_set.js

@@ -0,0 +1,62 @@
+function match_query(words, query) {
+  let result = [];
+
+  let query_components = query.split('?');
+
+  words.filter(word => {
+    let word_copy = word;
+    if (word.length !== query.length) {
+      return false;
+    } else {
+      for (let component of query_components) {
+        if (component === '') {
+          word_copy.slice(1, word_copy.length);
+        } else {
+          if (word_copy.indexOf(component) !== 0) {
+            return false;
+          }
+        }
+      }
+      return true;
+    }
+  });
+
+  return result;
+}
+
+
+function getAllKeys() {
+  return(fs.ls);
+}
+
+function removeItem(key) {
+  fs.remove(key);
+  console.log('Deleted');
+}
+
+function setItem(key, value, callback) {
+  operations.add_operation_to_queue(fs.writeFile(hash(key), value)
+    .done(result => {
+      callback(); 
+      return result 
+    })
+  );
+}
+
+function execute_file_operations(operations) {
+  for (operation of operations) {
+    operation().done(() => {
+      continue;
+    });
+  }
+}
+
+function add_operation_to_queue(key, value, operation) {
+  operations.push(setItem(key, value, print_result));
+}
+
+function execute_operations() {
+  while (!operations.empty()) {
+    execute_file_operations(operations);
+  }
+}

solutions/08-recursion-and-dynamic-programming/max_nonadjacent_subset.js

@@ -0,0 +1,17 @@
+function max_nonadjacent_subset(numbers) {
+  let one_previous = 0;
+  let two_previous = 0;
+
+  let helper = index => {
+    let new_addend = numbers[index];
+    let new_max = one_previous > two_previous + new_addend ? one_previous : new_addend + two_previous;
+    two_previous = one_previous;
+    one_previous = new_max;
+  }
+
+  for (let i = 0; i < numbers.length; i++) {
+    helper(i);
+  }
+
+  return one_previous;
+}