feat(bst): in-order, pre-order, post-order, bfs, dfs

Author: amejiarosario

src/data-structures/trees/binary-search-tree.js

@@ -1,5 +1,6 @@
 const TreeNode = require('./tree-node');
 const Queue = require('../queues/queue');
+const Stack = require('../stacks/stack');
 
 class BinarySearchTree {
   constructor() {
@@ -75,6 +76,33 @@ class BinarySearchTree {
     return false;
   }
 
+  /**
+   * Represent Binary Tree as an array.
+   *
+   * Leaf nodes will have two `undefined` descendents.
+   *
+   * The array representation of the binary tree is as follows:
+   *
+   * First element (index=0) is the root.
+   * The following two elements (index=1,2) are descendents of the root: left (a) and right (b).
+   * The next two elements (index=3,4) are the descendents of a
+   * The next two elements (index=5,6) are the descendents of b and so on.
+   *
+   *  0     1            2             3       4        5       6        n
+   * [root, a=root.left, b=root.right, a.left, a.right, b.left, b.right, ...]
+   *
+   * You can also find the parents as follows
+   *
+   * e.g.
+   * Parent 0: children 1,2
+   * Parent 1: children 3,4
+   * Parent 2: children 5,6
+   * Parent 3: children 7,8
+   *
+   * Given any index you can find the parent index with the following formula:
+   *
+   * parent = (index) => Math.floor((index-1)/2)
+   */
   toArray() {
     const array = [];
     const queue = new Queue();
@@ -91,6 +119,71 @@ class BinarySearchTree {
 
     return array;
   }
+
+  /**
+   * Breath-first search for a tree (always starting from the root element)
+   */
+  * bfs() {
+    const queue = new Queue();
+
+    queue.add(this.root);
+
+    while (!queue.isEmpty()) {
+      const node = queue.remove();
+      yield node;
+      node.descendents.forEach(child => queue.add(child));
+    }
+  }
+
+  /**
+   * Depth-first search for a tree (always starting from the root element)
+   */
+  * dfs() {
+    const stack = new Stack();
+
+    stack.add(this.root);
+
+    while (!stack.isEmpty()) {
+      const node = stack.remove();
+      yield node;
+      node.descendents.forEach(child => stack.add(child));
+    }
+  }
+
+  /**
+   * In-order traversal on a tree
+   *
+   * If the tree is a BST, then the values will be sorted in ascendent order
+   *
+   * @param {TreeNode} node first node to start the traversal
+   */
+  * inOrderTraversal(node = this.root) {
+    if (node.left) { yield* this.inOrderTraversal(node.left); }
+    yield node;
+    if (node.right) { yield* this.inOrderTraversal(node.right); }
+  }
+
+  /**
+   * Pre-order traversal on a tree
+   *
+   * @param {TreeNode} node first node to start the traversal
+   */
+  * preOrderTraversal(node = this.root) {
+    yield node;
+    if (node.left) { yield* this.inOrderTraversal(node.left); }
+    if (node.right) { yield* this.inOrderTraversal(node.right); }
+  }
+
+  /**
+   * Post-order traversal on a tree
+   *
+   * @param {TreeNode} node first node to start the traversal
+   */
+  * postOrderTraversal(node = this.root) {
+    if (node.left) { yield* this.inOrderTraversal(node.left); }
+    if (node.right) { yield* this.inOrderTraversal(node.right); }
+    yield node;
+  }
 }
 
 module.exports = BinarySearchTree;

src/data-structures/trees/binary-search-tree.spec.js

@@ -65,6 +65,7 @@ describe('Binary Search Tree', () => {
     xdescribe('#remove', () => {
       it('should remove value 2', () => {
         expect(bst.remove(2)).toBe(true);
+        expect(bst.toArray()).toEqual([10, undefined, 30, undefined, undefined, 15, 40]);
         expect(root.left).toBe(undefined);
       });
 
@@ -73,6 +74,77 @@ describe('Binary Search Tree', () => {
       });
     });
 
+    describe('#bfs', () => {
+      it('should visit nodes on BFS order using iterator', () => {
+        const bfs = bst.bfs();
+        expect(bfs.next().value).toBe(root); // 10
+        expect(bfs.next().value).toBe(n2);
+        expect(bfs.next().value.value).toBe(30);
+        expect(bfs.next().value.value).toBe(15);
+        expect(bfs.next()).toMatchObject({ value: { value: 40 }, done: false });
+        expect(bfs.next().done).toBe(true);
+      });
+
+      it('should generate an array from bfs', () => {
+        const nodes = Array.from(bst.bfs());
+        const values = nodes.map(node => node.value);
+        expect(values).toEqual([10, 2, 30, 15, 40]);
+      });
+    });
+
+    describe('#dfs', () => {
+      it('should visit nodes on dfs order using iterator', () => {
+        const dfs = bst.dfs();
+        expect(dfs.next().value).toBe(root); // 10
+        expect(dfs.next().value.value).toBe(30);
+        expect(dfs.next()).toMatchObject({ value: { value: 40 }, done: false });
+        expect(dfs.next().value.value).toBe(15);
+        expect(dfs.next().value).toBe(n2);
+        expect(dfs.next().done).toBe(true);
+      });
+
+      it('should generate an array from dfs', () => {
+        const nodes = Array.from(bst.dfs());
+        const values = nodes.map(node => node.value);
+        expect(values).toEqual([10, 30, 40, 15, 2]);
+      });
+    });
+
+    describe('#inOrderTraversal', () => {
+      it('should visit nodes on order using iterator', () => {
+        const ordered = bst.inOrderTraversal();
+
+        expect(ordered.next().value).toBe(n2);
+        expect(ordered.next().value).toBe(root); // 10
+        expect(ordered.next().value.value).toBe(15);
+        expect(ordered.next().value.value).toBe(30);
+        expect(ordered.next()).toMatchObject({ value: { value: 40 }, done: false });
+        expect(ordered.next().done).toBe(true);
+      });
+
+      it('should generate an array', () => {
+        const nodes = Array.from(bst.inOrderTraversal());
+        const values = nodes.map(node => node.value);
+        expect(values).toEqual([2, 10, 15, 30, 40]);
+      });
+    });
+
+    describe('#preOrderTraversal', () => {
+      it('should generate an array from preOrderTraversal', () => {
+        const nodes = Array.from(bst.preOrderTraversal());
+        const values = nodes.map(node => node.value);
+        expect(values).toEqual([10, 2, 15, 30, 40]);
+      });
+    });
+
+    describe('#postOrderTraversal', () => {
+      it('should generate an array from postOrderTraversal', () => {
+        const nodes = Array.from(bst.postOrderTraversal());
+        const values = nodes.map(node => node.value);
+        expect(values).toEqual([2, 15, 30, 40, 10]);
+      });
+    });
+
     describe('#toArray', () => {
       it('should serialize the tree as an array', () => {
         expect(bst.toArray()).toEqual([10, 2, 30, undefined, undefined, 15, 40,