+ /**
+ * AVL tree, a Binary Search Tree that satisfies the Height-Balance
+ * Property.
+ *
+ * @example
+ * var avlTree = require('path-to-algorithms/src/data-structures'+
+ * '/avl-tree');
+ * var avl = new avlTree.AVLTree();
+ *
+ * avl.insert(2000);
+ * avl.insert(1989);
+ * avl.insert(1991);
+ * avl.insert(2001);
+ * avl.insert(1966);
+ *
+ * @module data-structures/avl-tree
+ */
+(function (exports) {
+ 'use strict';
+
+ /**
+ * Node of the tree.
+ *
+ * @public
+ * @constructor
+ * @param {Number|String} value Value of the node.
+ * @param {Node} left Left sibling.
+ * @param {Node} right Right sibling.
+ * @param {Node} parent Parent of the node.
+ * @param {Number} height Height of the node.
+ */
+ exports.Node = function (value, left, right, parent, height) {
+ /**
+ * @member {Number|String}
+ */
+ this.value = value;
+ this._left = left;
+ this._right = right;
+ this._parent = parent;
+ this._height = height;
+ };
+
+ /**
+ * AVL Tree.
+ *
+ * @public
+ * @constructor
+ */
+ exports.AVLTree = function () {
+ this._root = null;
+ };
+
+ /**
+ * Calculates the height of a node based on height
+ * property of children.
+ *
+ * @public
+ * @method
+ * @param {Node} node Given node's height is returned.
+ */
+ exports.AVLTree.prototype._getHeightAtNode = function (node) {
+ if (node._left !== null && node._right !== null){
+ var height = Math.max(node._left._height, node._right._height);
+ height += 1;
+ return height;
+ } else if (node._left !== null){
+ return node._left._height + 1;
+ } else if (node._right !== null){
+ return node._right._height + 1;
+ } else {
+ return 1;
+ }
+ };
+
+ /**
+ * Checks if a given node has an imbalance.
+ *
+ * @public
+ * @method
+ * @param {Node} node Given node's children are checked for
+ * imbalance.
+ */
+ exports.AVLTree.prototype._isBalancedAtNode = function (node) {
+ if (node._left !== null && node._right !== null){
+ return (Math.abs(node._left._height - node._right._height) <= 1);
+ }
+ if (node._right !== null && node._left === null){
+ return node._right._height < 2;
+ }
+ if (node._left !== null && node._right === null){
+ return node._left._height < 2;
+ }
+ return true;
+ };
+
+ /**
+ * Gets the nodes to be restructured during an AVL restructure
+ * after a remove/delete takes place.
+ *
+ * @public
+ * @method
+ * @param {Array} traveledNodes Array of previously traveled nodes
+ * that are used to help determine the nodes to be restructured.
+ */
+ exports.AVLTree.prototype._getNodesToRestructureRemove = function (traveledNodes) {
+ // z is last traveled node - imbalance found at z
+ var zIndex = traveledNodes.length;
+ zIndex -= 1;
+ var z = traveledNodes[zIndex];
+ // y should be child of z with larger height
+ // (cannot be ancestor of removed node)
+ var y;
+ if (z._left !== null && z._right !== null){
+ y = (z._left === y) ? z._right : z._left;
+ } else if (z._left !== null && z._right === null){
+ y = z._left;
+ } else if (z._right !== null && z._left === null){
+ y = z._right;
+ }
+ // x should be tallest child of y.
+ // If children same height, x should be child of y
+ // that has same orientation as z to y.
+ var x;
+ if (y._left !== null && y._right !== null){
+ if (y._left._height > y._right._height){
+ x = y._left;
+ } else if (y._left._height < y._right._height){
+ x = y._right;
+ } else if (y._left._height === y._right._height){
+ x = (z._left === y) ? y._left : y._right;
+ }
+ } else if (y._left !== null && y._right === null){
+ x = y._left;
+ } else if (y._right !== null && y._left === null){
+ x = y._right;
+ }
+ return [x, y, z];
+ };
+
+ /**
+ * Gets the nodes to be restructured during an AVL restructure
+ * after an insert takes place.
+ *
+ * @public
+ * @method
+ * @param {Array} traveledNodes Array of previously traveled nodes
+ * that are used to help determine the nodes to be restructured.
+ */
+ exports.AVLTree.prototype._getNodesToRestructureInsert = function (traveledNodes) {
+ // z is last traveled node - imbalance found at z
+ var zIndex = traveledNodes.length;
+ zIndex -= 1;
+ var z = traveledNodes[zIndex];
+ // y should be child of z with larger height
+ // (must be ancestor of inserted node)
+ // therefore, last traveled node is correct.
+ var yIndex = traveledNodes.length;
+ yIndex -= 2;
+ var y = traveledNodes[yIndex];
+ // x should be tallest child of y.
+ // If children same height, x should be ancestor
+ // of inserted node (in traveled path).
+ var x;
+ if (y._left !== null && y._right !== null){
+ if (y._left._height > y._right._height){
+ x = y._left;
+ } else if (y._left._height < y._right._height){
+ x = y._right;
+ } else if (y._left._height === y._right._height){
+ var xIndex = traveledNodes.length;
+ xIndex -= 3;
+ x = traveledNodes[xIndex];
+ }
+ } else if (y._left !== null && y._right === null){
+ x = y._left;
+ } else if (y._right !== null && y._left === null){
+ x = y._right;
+ }
+ return [x, y, z];
+ };
+
+ /**
+ * Maintains the height balance property by
+ * walking to root and checking for invalid height
+ * differences between children and restructuring
+ * appropriately.
+ *
+ * @public
+ * @method
+ * @param {Node} node Started node.
+ * @param {Boolean} isRemove Represents if method was called after remove.
+ */
+ exports.AVLTree.prototype._maintainHeightBalanceProperty = function (node, isRemove) {
+ var current = node;
+ var traveledNodes = [];
+ while (current !== null){
+ traveledNodes.push(current);
+ current._height = this._getHeightAtNode(current);
+ if (!this._isBalancedAtNode(current)){
+ var nodesToBeRestructured = (isRemove)
+ ? this._getNodesToRestructureRemove(traveledNodes)
+ : this._getNodesToRestructureInsert(traveledNodes);
+ this._restructure(nodesToBeRestructured);
+ }
+ current = current._parent;
+ }
+ };
+
+ /**
+ * Identifies the pattern of given nodes, then calls
+ * the appropriate pattern rotator.
+ *
+ * @public
+ * @method
+ * @param {Array} nodesToBeRestructured
+ * array of nodes, in format, [x, y, z], to be restructured
+ */
+ exports.AVLTree.prototype._restructure = function (nodesToBeRestructured) {
+ var x = nodesToBeRestructured[0];
+ var y = nodesToBeRestructured[1];
+ var z = nodesToBeRestructured[2];
+ //Determine Rotation Pattern
+ if (z._right === y && y._right === x){
+ this._rightRight(x, y, z);
+ } else if (z._left === y && y._left === x){
+ this._leftLeft(x, y, z);
+ } else if (z._right === y && y._left === x){
+ this._rightLeft(x, y, z);
+ } else if (z._left === y && y._right === x){
+ this._leftRight(x, y, z);
+ }
+ };
+
+ /**
+ * Rotates the given nodes from a right right pattern
+ * to a parent, with 2 children.
+ *
+ * @public
+ * @method
+ * @param {Node} x node with lowest height to be restructured.
+ * @param {Node} y parent of x parameter.
+ * @param {Node} z grandparent of x, largest height.
+ */
+ exports.AVLTree.prototype._rightRight = function (x, y, z) {
+ /*
+ z
+ y => y
+ x z x
+ */
+ // pass z parent to y and move y's left to z's right
+ if (z._parent !== null){
+ var orientation = (z._parent._left === z) ? '_left' : '_right';
+ z._parent[orientation] = y;
+ y._parent = z._parent;
+ } else {
+ this._root = y;
+ y._parent = null;
+ }
+ // z adopts y's left.
+ z._right = y._left;
+ if (z._right !== null){
+ z._right._parent = z;
+ }
+ // y adopts z
+ y._left = z;
+ z._parent = y;
+ // Correct each nodes height - order matters, children first
+ x._height = this._getHeightAtNode(x);
+ z._height = this._getHeightAtNode(z);
+ y._height = this._getHeightAtNode(y);
+ };
+
+ /**
+ * Rotates the given nodes from a left left pattern
+ * to a parent, with 2 children.
+ *
+ * @public
+ * @method
+ * @param {Node} x node with lowest height to be restructured.
+ * @param {Node} y parent of x parameter.
+ * @param {Node} z grandparent of x, largest height.
+ */
+ exports.AVLTree.prototype._leftLeft = function (x, y, z) {
+ /*
+ z
+ y => y
+ x x z
+ */
+ //pass z parent to y and move y's right to z's left
+ if (z._parent !== null){
+ var orientation = (z._parent._left === z) ? '_left' : '_right';
+ z._parent[orientation] = y;
+ y._parent = z._parent;
+ } else {
+ this._root = y;
+ y._parent = null;
+ }
+ z._left = y._right;
+ if (z._left !== null) {
+ z._left._parent = z;
+ }
+ //fix y right child
+ y._right = z;
+ z._parent = y;
+ // Correct each nodes height - order matters, children first
+ x._height = this._getHeightAtNode(x);
+ z._height = this._getHeightAtNode(z);
+ y._height = this._getHeightAtNode(y);
+ };
+
+ /**
+ * Rotates the given nodes from a right left pattern
+ * to a parent, with 2 children.
+ *
+ * @public
+ * @method
+ * @param {Node} x node with lowest height to be restructured.
+ * @param {Node} y parent of x parameter.
+ * @param {Node} z grandparent of x, largest height.
+ */
+ exports.AVLTree.prototype._rightLeft = function (x, y, z) {
+ /*
+ z
+ y => x
+ x z y
+ */
+ //pass z parent to x
+ if (z._parent !== null){
+ var orientation = (z._parent._left === z) ? '_left' : '_right';
+ z._parent[orientation] = x;
+ x._parent = z._parent;
+ } else {
+ this._root = x;
+ x._parent = null;
+ }
+ // Adoptions
+ z._right = x._left;
+ if (z._right !== null){
+ z._right._parent = z;
+ }
+ y._left = x._right;
+ if (y._left !== null){
+ y._left._parent = y;
+ }
+ // Point to new children (x new parent)
+ x._left = z;
+ x._right = y;
+ x._left._parent = x;
+ x._right._parent = x;
+ // Correct each nodes height - order matters, children first
+ y._height = this._getHeightAtNode(y);
+ z._height = this._getHeightAtNode(z);
+ x._height = this._getHeightAtNode(x);
+ };
+
+ /**
+ * Rotates the given nodes from a left right pattern
+ * to a parent, with 2 children.
+ *
+ * @public
+ * @method
+ * @param {Node} x node with lowest height to be restructured.
+ * @param {Node} y parent of x parameter.
+ * @param {Node} z grandparent of x, largest height.
+ */
+ exports.AVLTree.prototype._leftRight = function (x, y, z) {
+ /*
+ z
+ y => x
+ x y z
+ */
+ //pass z parent to x
+ if (z._parent !== null){
+ var orientation = (z._parent._left === z) ? '_left' : '_right';
+ z._parent[orientation] = x;
+ x._parent = z._parent;
+ } else {
+ this._root = x;
+ x._parent = null;
+ }
+ // Adoptions
+ z._left = x._right;
+ if (z._left !== null){
+ z._left._parent = z;
+ }
+ y._right = x._left;
+ if (y._right !== null){
+ y._right._parent = y;
+ }
+ // Point to new children (x new parent)
+ x._right = z;
+ x._left = y;
+ x._left._parent = x;
+ x._right._parent = x;
+ // Correct each nodes height - order matters, children first
+ y._height = this._getHeightAtNode(y);
+ z._height = this._getHeightAtNode(z);
+ x._height = this._getHeightAtNode(x);
+ };
+
+ /**
+ * Inserts a node into the AVL Tree.<br><br>
+ * Time complexity: O(log N) in the average case
+ * and O(N) in the worst case.
+ *
+ * @public
+ * @method
+ * @param {Number|String} value Node value.
+ * @param {Node} current Current node.
+ */
+ exports.AVLTree.prototype.insert = function (value, current) {
+ if (this._root === null) {
+ this._root = new exports.Node(value, null, null, null, 1);
+ this._maintainHeightBalanceProperty(this._root);
+ return;
+ }
+ var insertKey;
+ current = current || this._root;
+ if (current.value > value) {
+ insertKey = '_left';
+ } else {
+ insertKey = '_right';
+ }
+ if (!current[insertKey]) {
+ current[insertKey] = new exports.Node(value, null, null, current);
+ this._maintainHeightBalanceProperty(current[insertKey], false);
+ } else {
+ this.insert(value, current[insertKey]);
+ }
+ };
+
+ /**
+ * In-order traversal from the given node.
+ *
+ * @private
+ * @param {Node} current Node from which to start the traversal.
+ * @param {Function} callback Callback which
+ * will be called for each traversed node.
+ */
+ exports.AVLTree.prototype._inorder = function (current, callback) {
+ if (!current) {
+ return;
+ }
+ this._inorder(current._left, callback);
+ if (typeof callback === 'function') {
+ callback(current);
+ }
+ this._inorder(current._right, callback);
+ };
+
+ /**
+ * In-order traversal of the whole AVL tree.
+ *
+ * @public
+ * @method
+ * @param {Function} callback Callback which will be
+ * called for each traversed node.
+ */
+ exports.AVLTree.prototype.inorder = function (callback) {
+ return this._inorder(this._root, callback);
+ };
+
+ /**
+ * Post-order traversal from given node.
+ *
+ * @private
+ * @param {Node} current Node from which to start the traversal.
+ * @param {Function} callback Callback which will
+ * be called for each traversed node
+ */
+ exports.AVLTree.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 Callback which
+ * will be called for each traversed node.
+ */
+ exports.AVLTree.prototype.postorder = function (callback) {
+ return this._postorder(this._root, callback);
+ };
+
+ /**
+ * Pre-order traversal of the tree from given node.
+ *
+ * @private
+ * @param {Node} current Node from which to start the traversal.
+ * @param {Function} callback Callback which
+ * will be called for each traversed node.
+ */
+ exports.AVLTree.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 Callback which will
+ * be called for each traversed node.
+ */
+ exports.AVLTree.prototype.preorder = function (callback) {
+ return this._preorder(this._root, callback);
+ };
+
+ /**
+ * Finds a node by it's value.<br><br>
+ * Average time complexity: O(log N).
+ *
+ * @public
+ * @param {Number|String} value of the node which should be found.
+ */
+ exports.AVLTree.prototype.find = function (value) {
+ return this._find(value, this._root);
+ };
+
+ /**
+ * Finds a node by it's value in a given sub-tree.
+ * Average time complexity: O(log N).
+ *
+ * @private
+ * @param {Number|String} value of the node which should be found.
+ * @param {Node} current node to be checked.
+ */
+ exports.AVLTree.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 Parent node.
+ * @param {Node} oldChild Child to be replaced.
+ * @param {Node} newChild Child replacement.
+ */
+ exports.AVLTree.prototype._replaceChild = function (parent, oldChild, newChild) {
+ if (parent === null) {
+ this._root = newChild;
+ if (this._root !== null){
+ 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. <br><br>
+ * Average runtime complexity: O(log N).
+ *
+ * @public
+ * @param {Number|String} value of node to be removed
+ * @returns {Boolean} True/false depending
+ * on whether the given node is removed.
+ */
+ exports.AVLTree.prototype.remove = function (value) {
+ var node = this.find(value);
+ if (!node) {
+ return false;
+ }
+ if (node._left && node._right) {
+ var min = this._findMin(node._right);
+ var 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);
+ this._maintainHeightBalanceProperty(node._left, true);
+ } else if (node._right) {
+ this._replaceChild(node._parent, node, node._right);
+ this._maintainHeightBalanceProperty(node._right, true);
+ } else {
+ this._replaceChild(node._parent, node, null);
+ this._maintainHeightBalanceProperty(node._parent, true);
+ }
+ return true;
+ }
+ };
+
+ /**
+ * Finds the node with minimum value in given sub-tree.
+ *
+ * @private
+ * @param {Node} node Root of the sub-tree.
+ * @param {Number|String} current Current minimum value of the sub-tree.
+ * @returns {Node} Node with the minimum value in the sub-tree.
+ */
+ exports.AVLTree.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} node Root of the sub-tree.
+ * @param {Number|String} current Current maximum value of the sub-tree.
+ * @returns {Node} Node with the maximum value in the sub-tree.
+ */
+ exports.AVLTree.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.
+ */
+ exports.AVLTree.prototype.findMin = function () {
+ return this._findMin(this._root);
+ };
+
+ /**
+ * Finds the node with maximum value in the whole tree.
+ *
+ * @public
+ * @returns {Node} The maximum node of the tree.
+ *
+ */
+ exports.AVLTree.prototype.findMax = function () {
+ return this._findMax(this._root);
+ };
+
+ exports.AVLTree.prototype._isBalanced = function (current) {
+ if (!current) {
+ return true;
+ }
+ return this._isBalanced(current._left) &&
+ this._isBalanced(current._right) &&
+ Math.abs(this._getHeight(current._left) -
+ this._getHeight(current._right)) <= 1;
+ };
+
+ /**
+ * Returns whether the AVL Tree is balanced.
+ *
+ * @public
+ * @returns {Boolean} Whether the tree is balanced or not.
+ */
+ exports.AVLTree.prototype.isBalanced = function () {
+ return this._isBalanced(this._root);
+ };
+
+ /**
+ * Finds the diameter of the AVL tree.
+ *
+ * @public
+ * @returns {Number} The longest path in the AVL Tree.
+ */
+ exports.AVLTree.prototype.getDiameter = function () {
+ var getDiameter = function (root) {
+ if (!root) {
+ return 0;
+ }
+ var leftHeight = this._getHeight(root._left);
+ var rightHeight = this._getHeight(root._right);
+ var path = leftHeight + rightHeight + 1;
+ return Math.max(path, getDiameter(root._left), getDiameter(root._right));
+ }.bind(this);
+ return getDiameter(this._root);
+ };
+
+ /**
+ * Returns the height of the tree.
+ *
+ * @public
+ * @returns {Number} The height of the tree.
+ */
+ exports.AVLTree.prototype.getTreeHeight = function () {
+ return this._getHeight(this._root);
+ };
+
+ exports.AVLTree.prototype._getHeight = function (node) {
+ if (!node) {
+ return 0;
+ }
+ return 1 + Math.max(this._getHeight(node._left),
+ this._getHeight(node._right));
+ };
+
+ /**
+ * Finds the lowest common ancestor of two nodes.
+ *
+ * @public
+ * @returns {Node} The lowest common ancestor of the two nodes or null.
+ */
+ exports.AVLTree.prototype.lowestCommonAncestor = function (firstNode, secondNode) {
+ return this._lowestCommonAncestor(firstNode, secondNode, this._root);
+ };
+
+ exports.AVLTree.prototype._lowestCommonAncestor = function (firstNode, secondNode, current) {
+ var firstNodeInLeft = this._existsInSubtree(firstNode, current._left);
+ var secondNodeInLeft = this._existsInSubtree(secondNode, current._left);
+ var firstNodeInRight = this._existsInSubtree(firstNode, current._right);
+ var secondNodeInRight = this._existsInSubtree(secondNode, current._right);
+ if ((firstNodeInLeft && secondNodeInRight) ||
+ (firstNodeInRight && secondNodeInLeft)) {
+ return current;
+ }
+ if (secondNodeInLeft && firstNodeInLeft) {
+ return this._lowestCommonAncestor(firstNode, secondNode, current._left);
+ }
+ if (secondNodeInRight && secondNodeInLeft) {
+ return this._lowestCommonAncestor(firstNode, secondNode, current._right);
+ }
+ return null;
+ };
+
+ exports.AVLTree.prototype._existsInSubtree = function (node, root) {
+ if (!root) {
+ return false;
+ }
+ if (node === root.value) {
+ return true;
+ }
+ return this._existsInSubtree(node, root._left) ||
+ this._existsInSubtree(node, root._right);
+ };
+
+})(typeof window === 'undefined' ? module.exports : window);
+
+
+ 