refactored from ES6 classes to factory function to Binary Tree Data Strucutre

Author: crizstian

10-chapter-Binary-Tree/index.js

@@ -0,0 +1,4 @@
+(function (exports) {
+  const {tree} = require('./tree.module')
+  Object.assign(exports, {tree})
+}((typeof module.exports !== undefined) ? module.exports : window))

10-chapter-Binary-Tree/readme.md

@@ -0,0 +1,46 @@
+# Binary Tree and Binary Search Tree
+
+### Code Examples
+- [Binary Tree Structure](./tree.module.js)
+- [Import Module](./index.js)
+
+### Description
+
+`Binary trees` are chosen over other more primary data structures because you can search a binary tree very quickly (as opposed to a linked list, for example) and you can quickly insert and delete data from a binary tree (as opposed to an array).
+
+common operations you can perform on graphs:
+
+**Additions**
+- `insert`: insert a node to tree, if the node is lower than the root it place it to left otherwise to the right
+
+**Removals**
+
+- `remove`: removes a node from the tree
+
+**Search**
+
+- `find`: Search for a specific value
+- `maxValue`: Search for the minimum value
+- `minValue`: Search for the maximum value
+
+**Traversals**
+
+- `inOrder`: In this traversal method, the left subtree is visited first, then the root and later the right sub-tree
+- `preOrder`: In this traversal method, the root node is visited first, then the left subtree and finally the right subtree.
+- `postOrder`: In this traversal method, the root node is visited last, hence the name. First we traverse the left subtree, then the right subtree and finally the root node.
+
+![](https://blog.penjee.com/wp-content/uploads/2015/11/binary-search-tree-sorted-array-animation.gif)
+
+
+**Display**
+
+- `show`: displays the node data
+
+
+### Example Use Cases:
+
+- Binary Search Tree - Used in many search applications where data is constantly entering/leaving, such as the map and set objects in many languages' libraries.
+- Binary Space Partition - Used in almost every 3D video game to determine what objects need to be rendered.
+- Binary Trees - Used in almost every high-bandwidth router for storing router-tables.
+- Hash Trees - used in p2p programs and specialized image-signatures in which a hash needs to be verified, but the whole file is not available.
+- Heaps - Used in implementing efficient priority-queues, which in turn are used for scheduling processes in many operating systems, Quality-of-Service in routers, and A* (path-finding algorithm used in AI applications, including robotics and video games). Also used in heap-sort.

10-chapter-Binary-Tree/test.js

@@ -0,0 +1,26 @@
+const {tree} = require('./index')
+
+const nums = tree()
+nums.insert(23)
+nums.insert(45)
+nums.insert(16)
+nums.insert(37)
+nums.insert(3)
+nums.insert(99)
+nums.insert(22)
+
+console.log('Inorder traversal: ')
+nums.inOrder(nums.getRoot())
+console.log('\nPreorder traversal: ')
+nums.preOrder(nums.getRoot())
+console.log('\nPostorder traversal: ')
+nums.postOrder(nums.getRoot())
+console.log(`Find value 45: `)
+console.log(nums.find(45))
+
+test('Binary tree', assert => {
+  assert.equal(nums.totalNodes(), 7, `Total of nodes is ${nums.totalNodes()}`)
+  assert.equal(nums.totalEdges(nums.getRoot()), 4, `Total of edges is ${nums.totalEdges(nums.getRoot())}`)
+  assert.equal(nums.maxValue(), 99, `Max value of the tree is ${nums.maxValue()}`)
+  assert.equal(nums.minValue(), 3, `Min value of the tree is ${nums.minValue()}`)
+})

10-chapter-Binary-Tree/tree.module.js

@@ -0,0 +1,143 @@
+(function (exports) {
+  const tree = (r = null, n = 0) => {
+    let nodes = n
+    let root = r
+
+    const node = (data, left = null, right = null) => {
+      const o = {
+        left: null,
+        right: null,
+        show () {
+          console.log(this.data)
+        }
+      }
+      return Object.assign(Object.create(o), {data, left, right})
+    }
+
+    const traversals = {
+      find (data) {
+        let current = root
+        while ((current.data !== data)) {
+          if (data < current.data) {
+            current = current.left
+          } else {
+            current = current.right
+          }
+          if (current === null) {
+            return undefined
+          }
+        }
+        return current
+      },
+      inOrder: function inOrder (node) {
+        if (!(node === null)) {
+          inOrder(node.left)
+          node.show()
+          inOrder(node.right)
+        }
+      },
+      preOrder: function preOrder (node) {
+        if (!(node === null)) {
+          node.show()
+          preOrder(node.left)
+          preOrder(node.right)
+        }
+      },
+      postOrder: function postOrder (node) {
+        if (!(node === null)) {
+          postOrder(node.left)
+          postOrder(node.right)
+          node.show()
+        }
+      }
+    }
+
+    const getValues = {
+      minValue () {
+        let current = root
+        while (!(current.left === null)) {
+          current = current.left
+        }
+        return current.data
+      },
+      maxValue () {
+        let current = root
+        while (!(current.right === null)) {
+          current = current.right
+        }
+        return current.data
+      },
+      totalNodes: () => nodes,
+      totalEdges: function totalEdges (node) {
+        if (node === null) {
+          return 0
+        }
+        if (node.left === null && node.right === null) {
+          return 1
+        } else {
+          return totalEdges(node.left) + totalEdges(node.right)
+        }
+      },
+      getRoot: () => root
+    }
+
+    const insert = (data) => {
+      const n = node(data)
+      if (root == null) {
+        root = n
+      } else {
+        let current = root
+        while (!(current === null)) {
+          let parent = current
+          if (data < current.data) {
+            current = current.left
+            if (current === null) {
+              parent.left = n
+            }
+          } else {
+            current = current.right
+            if (current === null) {
+              parent.right = n
+            }
+          }
+        }
+      }
+      nodes += 1
+    }
+
+    const remove = (data) => {
+      root = removeNode(getValues.getRoot(), data)
+    }
+
+    const removeNode = (node, data) => {
+      if (node === null) {
+        return null
+      }
+      if (data === node.data) {
+        if (node.left === null && node.right === null) {
+          return null
+        }
+        if (node.left === null) {
+          return node.right
+        }
+        if (node.right === null) {
+          return node.left
+        }
+
+        let tempNode = getValues.minValue(node.right)
+        node.data = tempNode.data
+        node.right = removeNode(node.right, data)
+        return node
+      } else if (data < node.data) {
+        node.left = removeNode(node.left, data)
+      } else {
+        node.right = removeNode(node.right, data)
+        return node
+      }
+    }
+
+    return Object.assign({}, {insert}, {remove}, traversals, getValues)
+  }
+
+  Object.assign(exports, {tree})
+}((typeof exports !== undefined) ? exports : window))