refactor DFS to accept a callback fn which it calls on the nodes in the specified order

Author: whbrown

Diff for: dist/datastructures/BinarySearchTree.js

@@ -49,29 +49,29 @@ class BinarySearchTree {
         // found!
         return startingNode;
     }
-    DFS(startingNode = this.root, options = { order: 'ascending' }) {
+    DFS(cbFn, startingNode = this.root, options = { order: 'ascending' }) {
+        // calls the callback function on the nodes in the specified order 
+        // could reorganize parameterization, little bit too verbose when user wants to use order: 'descending' they also have to pass in the root node
         if (startingNode === null)
             return null;
-        const array = [];
-        const helper = (node = startingNode, options = { order: 'ascending' }) => {
-            const { order } = options;
+        const { order } = options;
+        const helper = (node = startingNode) => {
             if (order === 'ascending') {
                 if (node.left)
                     helper(node.left);
-                array.push(node.value);
+                cbFn(node);
                 if (node.right)
                     helper(node.right);
             }
             if (order === 'descending') {
                 if (node.right)
-                    helper(node.right, { order: 'descending' });
-                array.push(node.value);
+                    helper(node.right);
+                cbFn(node);
                 if (node.left)
-                    helper(node.left, { order: 'descending' });
+                    helper(node.left);
             }
         };
-        helper(startingNode, options);
-        return array;
+        helper();
     }
     logTree(startingNode = this.root, options = { order: 'ascending' }) {
         if (!startingNode)

Diff for: dist/datastructures/BinarySearchTree.test.js

@@ -94,11 +94,14 @@ describe('depth first search', () => {
     });
     test('can log a populated tree in ascending order', () => {
         populateTree(BST);
-        expect(BST.DFS()).toEqual([1, 3, 4, 5, 6, 8, 9]);
+        let ascendingArray = [];
+        BST.DFS((node) => { ascendingArray.push(node.value); });
+        expect(ascendingArray).toEqual([1, 3, 4, 5, 6, 8, 9]);
     });
     test('can log a populated tree in descending order', () => {
         populateTree(BST);
-        console.log(BST.DFS(BST.root, { order: 'descending' }));
-        expect(BST.DFS(BST.root, { order: 'descending' })).toEqual([9, 8, 6, 5, 4, 3, 1]);
+        let descendingArray = [];
+        BST.DFS((node) => { descendingArray.push(node.value); }, BST.root, { order: 'descending' });
+        expect(descendingArray).toEqual([9, 8, 6, 5, 4, 3, 1]);
     });
 });

Diff for: src/datastructures/BinarySearchTree.test.ts

@@ -86,11 +86,14 @@ describe('depth first search', () => {
   })
   test('can log a populated tree in ascending order', () => {
     populateTree(BST);
-    expect(BST.DFS()).toEqual([1, 3, 4, 5, 6, 8, 9]);
+    let ascendingArray: number[] = [];
+    BST.DFS((node: BinaryTreeNode<number>) => { ascendingArray.push(node.value) });
+    expect(ascendingArray).toEqual([1, 3, 4, 5, 6, 8, 9]);
   })
   test('can log a populated tree in descending order', () => {
     populateTree(BST);
-    console.log(BST.DFS(BST.root, { order: 'descending' }));
-    expect(BST.DFS(BST.root, { order: 'descending' })).toEqual([9, 8, 6, 5, 4, 3, 1]);
+    let descendingArray: number[] = [];
+    BST.DFS((node: BinaryTreeNode<number>) => { descendingArray.push(node.value) }, BST.root, { order: 'descending' })
+    expect(descendingArray).toEqual([9, 8, 6, 5, 4, 3, 1]);
   })
 })

Diff for: src/datastructures/BinarySearchTree.ts

@@ -60,24 +60,24 @@ class BinarySearchTree<T> {
     return startingNode;
   }
 
-  DFS(startingNode: BinaryTreeNode<T> | null = this.root, options = { order: 'ascending' }): T[] | null {
+  DFS(cbFn: (node: BinaryTreeNode<T>) => void, startingNode: BinaryTreeNode<T> | null = this.root, options = { order: 'ascending' }) {
+    // calls the callback function on the nodes in the specified order 
+    // could reorganize parameterization, little bit too verbose when user wants to use order: 'descending' they also have to pass in the root node
     if (startingNode === null) return null;
-    const array: T[] = [];
-    const helper = (node: BinaryTreeNode<T> = startingNode, options = { order: 'ascending' }): void => {
-      const { order } = options;
+    const { order } = options;
+    const helper = (node: BinaryTreeNode<T> = startingNode): void => {
       if (order === 'ascending') {
         if (node.left) helper(node.left);
-        array.push(node.value);
+        cbFn(node);
         if (node.right) helper(node.right);
       }
       if (order === 'descending') {
-        if (node.right) helper(node.right, { order: 'descending' });
-        array.push(node.value);
-        if (node.left) helper(node.left, { order: 'descending' });
+        if (node.right) helper(node.right);
+        cbFn(node);
+        if (node.left) helper(node.left);
       }
     };
-    helper(startingNode, options);
-    return array;
+    helper();
   }
   logTree(startingNode: BinaryTreeNode<T> | null = this.root, options = { order: 'ascending' }): void {
     if (!startingNode) return console.log(null);