Binary search tree is added

Author: mgechev

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

@@ -0,0 +1,275 @@
+/**
+ * Implementation of binary search tree.
+ */
+
+/**
+ * A node of the tree
+ *
+ * @public
+ * @constructor
+ * @param {number|string} Value of the node
+ * @param {Node} Left subling
+ * @param {Node} Right sibling
+ * @param {Node} Parent of the node
+ */
+function Node(value, left, right, parent) {
+    this.value = value;
+    this._left = left;
+    this._right = right;
+    this._parent = parent;
+}
+
+/**
+ * Defines the binary tree
+ *
+ * @public
+ * @constructor
+ */ 
+function BinaryTree() {
+    this._root = null;
+}
+
+/**
+ * Inserts a node into the binary tree. The method's complexity is O(log n) in the average case and
+ * O(n) in the worst case.
+ *
+ * @public
+ * @param {number|string} Value
+ * @param {[Node]} Current node
+ */ 
+BinaryTree.prototype.insert = function (value, current) {
+    if (this._root === null) {
+        this._root = new Node(value, null, null, null);
+        return;
+    }
+    
+    var insertKey;
+    current = current || this._root;
+    if (current.value > value)
+        insertKey = '_left';
+    else 
+        insertKey = '_right';
+    if (!current[insertKey])
+        current[insertKey] = new Node(value, null, null, current);
+    else
+        this.insert(value, current[insertKey]);
+};
+
+/**
+ * Prints the nodes of the tree in order. It starts the tree traversal from a given node.
+ *
+ * @private
+ * @param {Node} Node from which to start the traversal
+ * @param {Function} Callback which will be called for each traversed node
+ */ 
+BinaryTree.prototype._inorder = function (current, callback) {
+    if (!current)
+        return;
+    this._inorder(current._left, callback);
+    if (typeof callback === 'function') 
+        callback(current);
+    this._inorder(current._right, callback);
+};
+
+/**
+ * Inorder traversal of the whole binary search tree
+ *
+ * @public
+ * @param {Function} Callback which will be called for each traversed node
+ */
+BinaryTree.prototype.inorder = function (callback) {
+    return this._inorder(this._root, callback);
+};
+
+/**
+ * Post-order traversal from given node
+ *
+ * @private
+ * @param {Node} Node from which to start the traversal
+ * @param {Function} Callback which will be called for each traversed node
+ */ 
+BinaryTree.prototype._postorder = function (current, callback) {
+    if (!current)
+        return;
+    if (typeof callback === 'function') 
+        callback(current);
+    this._postorder(current._left, callback);
+    this._postorder(current._right, callback);
+};
+
+/**
+ * Post-order traversal of the whole tree
+ *
+ * @public
+ * @param {Function} Callback which will be called for each traversed node
+ */ 
+BinaryTree.prototype.postorder = function (callback) {
+    return this._postorder(this._root, callback);
+};
+
+/**
+ * Pre-order traversal of the tree from given node
+ *
+ * @private
+ * @param {Node} Node from which to start the traversal
+ * @param {Function} Callback which will be called for each traversed node
+ */ 
+BinaryTree.prototype._preorder = function (current, callback) {
+    if (!current)
+        return;
+    if (typeof callback === 'function')
+        callback(current);
+    this._preorder(current._left, callback);
+    this._preorder(current._right, callback);
+};
+
+/**
+ * Pre-order preorder traversal of the whole tree
+ * 
+ * @public
+ * @param {Function} Callback which will be called for each traversed node
+ */
+BinaryTree.prototype.preorder = function (callback) {
+    return this._preorder(this._root, callback);
+};
+
+/**
+ * Finds a node by it's value. Average runtime complexity O(log n) 
+ *
+ * @public
+ * @param {number|string} Value of the node which should be found
+ */ 
+BinaryTree.prototype.find = function (value) {
+    return this._find(value, this._root);
+};
+
+/**
+ * Finds a node by it's value in given sub-tree. Average runtime complexity: O(log n).
+ *
+ * @private
+ * @param {number|string} Value of the node which should be found
+ * @param {Node} Current node to be checked
+ */
+BinaryTree.prototype._find = function (value, current) {
+    if (!current)
+        return null; 
+ 
+    if (current.value === value) 
+        return current;
+ 
+    if (current.value > value)
+        return this._find(value, current._left);
+ 
+    if (current.value < value)
+        return this._find(value, current._right);
+    
+};
+
+/**
+ * Replaces given child with new one, for given parent
+ *
+ * @private
+ * @param {Node} Parent node
+ * @param {Node} Child to be replaced
+ * @param {Node} Child replacement
+ */
+BinaryTree.prototype._replaceChild = function (parent, oldChild, newChild) {
+    if (!parent) {
+        this._root = newChild;
+        this._root._parent = null;
+    } else {
+
+        if (parent._left === oldChild)
+            parent._left = newChild;
+        else 
+            parent._right = newChild;
+
+        if (newChild) {
+            newChild._parent = parent;
+        }
+    }
+};
+
+/**
+ * Removes node from the tree. Average runtime complexity: O(log n).
+ *
+ * @public
+ * @param {Node} Node to be removed
+ * @returns {boolean} True/false depending on whether the given node is removed
+ */ 
+BinaryTree.prototype.remove = function (node) {
+    if (!node) 
+        return false;
+
+    if (node._left && node._right) {
+        var min = this._findMin(node._right),
+            temp = node.value;
+
+        node.value = min.value;
+        min.value = temp;
+        return this.remove(min);
+    } else { 
+        if (node._left)
+            this._replaceChild(node._parent, node, node._left);
+        else if (node._right)
+            this._replaceChild(node._parent, node, node._right);
+        else
+            this._replaceChild(node._parent, node, null);
+        return true;
+    }
+};
+
+/**
+ * Finds the node with minimum value in given sub-tree
+ *
+ * @private
+ * @param {Node} Root of the sub-tree
+ * @param {[number|string]} Current minimum value of the sub-tree
+ * @returns {Node} The node with minimum value in the sub-tree
+ */
+BinaryTree.prototype._findMin = function (node, current) {
+    current = current || { value: Infinity };
+    if (!node)
+        return current;
+    if (current.value > node.value) 
+        current = node;
+    return this._findMin(node._left, current);
+};
+
+/**
+ * Finds the node with maximum value in given sub-tree
+ *
+ * @private
+ * @param {Node} Root of the sub-tree
+ * @param {[number|string]} Current maximum value of the sub-tree
+ * @returns {Node} The node with maximum value in the sub-tree
+ */
+BinaryTree.prototype._findMax = function (node, current) {
+    current = current || { value: -Infinity };
+    if (!node)
+        return current;
+    if (current.value < node.value) 
+        current = node;
+    return this._findMax(node._right, current);
+};
+
+/**
+ * Finds the node with minimum value in the whole tree
+ *
+ * @public
+ * @returns {Node} The minimum node of the tree
+ */
+BinaryTree.prototype.findMin = function () {
+    return this._findMin(this._root);
+};
+
+/**
+ * Finds the maximum node of the tree
+ *
+ * @public
+ * @returns {Node} The maximum node of the tree
+ *
+ */
+BinaryTree.prototype.findMax = function () {
+    return this._findMax(this._root);
+};

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

@@ -10,7 +10,7 @@ function MaxHeap() {
 /**
  * Exchange indexes with start index given as argument
  * to turn the heap into valid maxheap. On a single call
- * this method maintains only a single "branch" of the heap
+ * this method maintains only a single "branch" of the heap. Complexity O(log n)
  *
  * @private
  * @param {number} index The parent
@@ -37,7 +37,7 @@ MaxHeap.prototype._heapify = function (index) {
 }
 
 /**
- * Increases the key for give index
+ * Increases the key for give index. Complexity O(log n).
  *
  * @public
  * @param {number} index Index which key should be increased
@@ -61,7 +61,7 @@ MaxHeap.prototype.increaseKey = function (index, value) {
 }
 
 /**
- * Adds new element to the heap
+ * Adds new element to the heap. Complexity O(log n).
  *
  * @public
  * @param {number} value The new value which will be inserted
@@ -73,7 +73,7 @@ MaxHeap.prototype.add = function (value) {
 }
 
 /**
- * Gets the current value which is on the top of the heap
+ * Gets the current value which is on the top of the heap. Complexity O(1).
  *
  * @public
  * returns {numner}  The current largest value which is on the top of the heap
@@ -83,7 +83,8 @@ MaxHeap.prototype.max = function () {
 }
 
 /**
- * Remove and return the current maximum value which is on the top of the heap
+ * Remove and return the current maximum value which is on the top of the heap.
+ * Complexity O(log n).
  *
  * @public
  * @returns {number} max Extracted value

src/data-structures/heap.js

@@ -0,0 +1,20 @@
+/**
+ * Finds the maximum sum of subarray's element of given array using the Kadane's algorithm
+ * It's complexity is O(n). The algorithm can be found here: https://en.wikipedia.org/wiki/Maximum_subarray_problem#Kadane.27s_algorithm
+ *
+ * @public
+ * @param {array} array Input array
+ * @returns {number} max The maximum sum of the elements of subarray of the input
+ *
+ */
+function maxSubarray(array) {
+    var currentMax = 0,
+        max = 0;
+
+    for (var i = 0; i < array.length; i += 1) {
+        currentMax = Math.max(0, currentMax + array[i]);
+        max = Math.max(max, currentMax);
+    }
+
+    return max;
+}