Updated a number of solutions to ensure they're using strict mode, updated JSDocs or added them where missing. Reordered function declarations so solutions are at the tops of files and utility methods are later.

Author: diadical

src/chapter1/ch1-q9.js

@@ -1,11 +1,5 @@
 'use strict';
 
-// Implementation of isSubstring function which is defined in question
-// can only be called once
-function isSubstring(str, substr) {
-  return str.includes(substr);
-}
-
 /**
  * Duplicate the rotated string, if the substring being searched is a different
  * rotation of the string then it will be a substring of the new string. Both
@@ -28,3 +22,9 @@ export function isRotatedSubstring(str1, str2) {
   }
   return isSubstring(str1 + str1, str2);
 }
+
+// Implementation of isSubstring function which is defined in question
+// can only be called once
+function isSubstring(str, substr) {
+  return str.includes(substr);
+}

src/chapter2/ch2-q6.js

@@ -43,18 +43,6 @@ export function isPalindromeStack(list) {
   return stack.length === 0;
 }
 
-function reverse(node, end) {
-  let prev = end,
-    next;
-  while (node) {
-    next = node.next;
-    node.next = prev;
-    prev = node;
-    node = next;
-  }
-  return prev;
-}
-
 /**
  * First find out the length of the list, then walk to the middle of the list.
  * Once the middle is reached if the list had an odd length then skip the middle
@@ -105,3 +93,15 @@ export function isPalindromeReverse(list) {
 
   return isPalindrome;
 }
+
+function reverse(node, end) {
+  let prev = end,
+    next;
+  while (node) {
+    next = node.next;
+    node.next = prev;
+    prev = node;
+    node = next;
+  }
+  return prev;
+}

src/chapter2/ch2-q7.js

@@ -2,14 +2,6 @@
 
 import { getLength } from './helpers';
 
-function skip(list, num) {
-  while (num > 0) {
-    list = list.next;
-    --num;
-  }
-  return list;
-}
-
 /**
  * Find out the length of the two lists first. If they intersect at some point
  * then the length of their tails will be the same and any difference in length
@@ -41,3 +33,11 @@ export function doIntersect(list1, list2) {
 
   return undefined;
 }
+
+function skip(list, num) {
+  while (num > 0) {
+    list = list.next;
+    --num;
+  }
+  return list;
+}

src/chapter2/helpers.js

@@ -1,3 +1,4 @@
+'use strict';
 
 export function linkedListToArray(list) {
   let arr = [],

src/chapter3/ch3-q4.js

@@ -1,4 +1,16 @@
+'use strict';
 
+/**
+ * Queues and Stacks have different orders for extracting items. To create a
+ * queue with stacks we have two stacks, one for inserting items and one for
+ * extracting them. When dequeuing an item if the extract stack is empty we
+ * use queue operations to pop all the items off the insert stack onto the
+ * extract stack which will now be in the right order for a queue.
+ *
+ * N = |MyQueue|
+ * Time: enqueue O(1), dequeue O(N)
+ * Additional space: O(N) - to hold the input items
+ */
 export class MyQueue {
   constructor() {
     this.eStack = [];

src/chapter3/ch3-q5.js

@@ -1,13 +1,5 @@
 'use strict';
 
-function peek(stack) {
-  return stack[stack.length - 1];
-}
-
-function isEmpty(stack) {
-  return stack.length === 0;
-}
-
 /**
  * Sort the stack by taking one item off the input stack at a time, find the
  * right place within the processed items in the temp stack to insert it into.
@@ -42,3 +34,11 @@ export function sortStack(stack) {
 
   return stack;
 }
+
+function peek(stack) {
+  return stack[stack.length - 1];
+}
+
+function isEmpty(stack) {
+  return stack.length === 0;
+}

src/chapter4/ch4-q01.js

@@ -1,5 +1,16 @@
 'use strict';
 
+/**
+ * One way to check if two nodes are connected is to do a BFS of the graph
+ * from the source node. BFS would be useful where the nodes have many out
+ * edges (degrees) and paths between pairs are not exceedingly deep as it will
+ * visit neighbours from the source node radiating outwards.
+ *
+ * N = |vertices|
+ * M = |edges|
+ * Time: O(M)
+ * Additional space: O(N)
+ */
 export function isConnectedBFS(graph, source, target) {
   let discovered = new Set(),
     queue = [source];
@@ -20,6 +31,21 @@ export function isConnectedBFS(graph, source, target) {
   return false;
 }
 
+/**
+ * One way to check if two nodes are connected is to do a DFS of the graph
+ * from the source node. DFS would be useful where the graph has really long
+ * paths and we want to travel as far as we can through that graph as quickly as
+ * possible. DFS can be recursive or use a stack and iteration.
+ *
+ * N = |vertices|
+ * M = |edges|
+ * Time: O(M)
+ * Additional space: O(N)
+ */
+export function isConnectedDFS(graph, source, target) {
+  return dfs(graph, new Set(), source, target);
+}
+
 function dfs(graph, discovered, source, target) {
   if (source === target) {
     return true;
@@ -34,7 +60,3 @@ function dfs(graph, discovered, source, target) {
   }
   return false;
 }
-
-export function isConnectedDFS(graph, source, target) {
-  return dfs(graph, new Set(), source, target);
-}

src/chapter4/ch4-q02.js

@@ -1,17 +1,6 @@
 'use strict';
-import { Tree } from './helpers';
 
-function add(tree, values, start, end) {
-  if (start === end) {
-    tree.add(values[start]);
-  }
-  else if (start < end) {
-    let mid = start + Math.floor((end - start) / 2);
-    tree.add(values[mid]);
-    add(tree, values, start, mid - 1);
-    add(tree, values, mid + 1, end);
-  }
-}
+import { Tree } from './helpers';
 
 /**
  * As the list is already sorted the best way to create a balanced tree is by
@@ -30,3 +19,15 @@ export function makeBalancedTree(values) {
   }
   return tree;
 }
+
+function add(tree, values, start, end) {
+  if (start === end) {
+    tree.add(values[start]);
+  }
+  else if (start < end) {
+    let mid = start + Math.floor((end - start) / 2);
+    tree.add(values[mid]);
+    add(tree, values, start, mid - 1);
+    add(tree, values, mid + 1, end);
+  }
+}

src/chapter4/ch4-q03.js

@@ -1,4 +1,5 @@
 'use strict';
+
 import { LinkedList } from './helpers';
 
 /**

src/chapter4/ch4-q05.js

@@ -1,5 +1,18 @@
 'use strict';
 
+/**
+ * To check if a tree is a valid BST we need to check that all the values under
+ * a node are within the ranges defined by the path we took to get there. For
+ * example, initially the root can have any value, every time we go down a left
+ * child that sets an upper bound on the valid values of their children by that
+ * nodes value. Every time you travel down the right child you lower bound the
+ * valid values of their children by that nodes value.
+ *
+ * N = |tree|
+ * Time: O(N)
+ * Additional space: O(lg N) - due to recursion. Assumes a balanced tree, worst
+ * case is O(N)
+ */
 export function isValidBST(tree) {
   if (!tree) {
     throw new Error('invalid tree');

src/chapter4/helpers.js

@@ -1,3 +1,4 @@
+'use strict';
 
 class TreeNode {
   constructor(value) {