suzanne.soy/whalesong
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

looking at the avltree implementation; ok, I think I understand it enough to edit it.

Browse Source
This commit is contained in:
Danny Yoo 2011-11-03 12:55:55 -04:00
parent 3653b24476
commit 78d875aac1
1 changed files with 386 additions and 364 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

750
js-assembler/runtime-src/avltree.js
View File

@ -1,7 +1,12 @@
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
// dyoo: the following code comes from the Google Closure Library. I've done // dyoo: the following code comes from the Google Closure Library. I've done
// light edits to flatten the namespace from goog.structs to just // edits to flatten the namespace from goog.structs to just
// AvlTree. // AvlTree, commented out inorderTraverse and reverseOrderTraverse.
//
// I'm considering changing the code to work with CPSed control flow.
//
// ----------------------------------------------------------------------
// Original license follows:
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
@ -58,8 +63,8 @@
* @implements {Collection} * @implements {Collection}
*/ */
var AvlTree = function(opt_comparator) { var AvlTree = function(opt_comparator) {
this.comparator_ = opt_comparator || this.comparator_ = opt_comparator ||
AvlTree.DEFAULT_COMPARATOR_; AvlTree.DEFAULT_COMPARATOR_;
}; };
@ -73,12 +78,12 @@ var AvlTree = function(opt_comparator) {
* @private * @private
*/ */
AvlTree.DEFAULT_COMPARATOR_ = function(a, b) { AvlTree.DEFAULT_COMPARATOR_ = function(a, b) {
if (String(a) < String(b)) { if (String(a) < String(b)) {
return -1; return -1;
} else if (String(a) > String(b)) { } else if (String(a) > String(b)) {
return 1; return 1;
} }
return 0; return 0;
}; };
@ -142,54 +147,54 @@ AvlTree.prototype.count_ = 0;
* @return {boolean} Whether value was inserted into the tree. * @return {boolean} Whether value was inserted into the tree.
*/ */
AvlTree.prototype.add = function(value) { AvlTree.prototype.add = function(value) {
// If the tree is empty, create a root node with the specified value // If the tree is empty, create a root node with the specified value
if (this.root_ == null) { if (this.root_ == null) {
this.root_ = new AvlTree.Node(value); this.root_ = new AvlTree.Node(value);
this.minNode_ = this.root_; this.minNode_ = this.root_;
this.maxNode_ = this.root_; this.maxNode_ = this.root_;
this.count_ = 1; this.count_ = 1;
return true; return true;
}
// Assume a node is not added and change status when one is
var retStatus = false;
// Depth traverse the tree and insert the value if we reach a null node
this.traverse_(function(node) {
var retNode = null;
if (this.comparator_(node.value, value) > 0) {
retNode = node.left;
if (node.left == null) {
var newNode = new AvlTree.Node(value, node);
node.left = newNode;
if (node == this.minNode_) {
this.minNode_ = newNode;
}
retStatus = true; // Value was added to tree
this.balance_(node); // Maintain the AVL-tree balance
}
} else if (this.comparator_(node.value, value) < 0) {
retNode = node.right;
if (node.right == null) {
var newNode = new AvlTree.Node(value, node);
node.right = newNode;
if (node == this.maxNode_) {
this.maxNode_ = newNode;
}
retStatus = true; // Value was added to tree
this.balance_(node); // Maintain the AVL-tree balance
}
} }
return retNode; // If null, we'll stop traversing the tree
});
// If a node was added, increment count // Assume a node is not added and change status when one is
if (retStatus) { var retStatus = false;
this.count_ += 1;
}
// Return true if a node was added, false otherwise // Depth traverse the tree and insert the value if we reach a null node
return retStatus; this.traverse_(function(node) {
var retNode = null;
if (this.comparator_(node.value, value) > 0) {
retNode = node.left;
if (node.left == null) {
var newNode = new AvlTree.Node(value, node);
node.left = newNode;
if (node == this.minNode_) {
this.minNode_ = newNode;
}
retStatus = true; // Value was added to tree
this.balance_(node); // Maintain the AVL-tree balance
}
} else if (this.comparator_(node.value, value) < 0) {
retNode = node.right;
if (node.right == null) {
var newNode = new AvlTree.Node(value, node);
node.right = newNode;
if (node == this.maxNode_) {
this.maxNode_ = newNode;
}
retStatus = true; // Value was added to tree
this.balance_(node); // Maintain the AVL-tree balance
}
}
return retNode; // If null, we'll stop traversing the tree
});
// If a node was added, increment count
if (retStatus) {
this.count_ += 1;
}
// Return true if a node was added, false otherwise
return retStatus;
}; };
@ -203,31 +208,31 @@ AvlTree.prototype.add = function(value) {
* the tree. * the tree.
*/ */
AvlTree.prototype.remove = function(value) { AvlTree.prototype.remove = function(value) {
// Assume the value is not removed and set the value when it is removed // Assume the value is not removed and set the value when it is removed
var retValue = null; var retValue = null;
// Depth traverse the tree and remove the value if we find it // Depth traverse the tree and remove the value if we find it
this.traverse_(function(node) { this.traverse_(function(node) {
var retNode = null; var retNode = null;
if (this.comparator_(node.value, value) > 0) { if (this.comparator_(node.value, value) > 0) {
retNode = node.left; retNode = node.left;
} else if (this.comparator_(node.value, value) < 0) { } else if (this.comparator_(node.value, value) < 0) {
retNode = node.right; retNode = node.right;
} else { } else {
retValue = node.value; retValue = node.value;
this.removeNode_(node); this.removeNode_(node);
}
return retNode; // If null, we'll stop traversing the tree
});
// If a node was removed, decrement count.
if (retValue) {
// Had traverse_() cleared the tree, set to 0.
this.count_ = this.root_ ? this.count_ - 1 : 0;
} }
return retNode; // If null, we'll stop traversing the tree
});
// If a node was removed, decrement count. // Return the value that was removed, null if the value was not in the tree
if (retValue) { return retValue;
// Had traverse_() cleared the tree, set to 0.
this.count_ = this.root_ ? this.count_ - 1 : 0;
}
// Return the value that was removed, null if the value was not in the tree
return retValue;
}; };
@ -235,10 +240,10 @@ AvlTree.prototype.remove = function(value) {
* Removes all nodes from the tree. * Removes all nodes from the tree.
*/ */
AvlTree.prototype.clear = function() { AvlTree.prototype.clear = function() {
this.root_ = null; this.root_ = null;
this.minNode_ = null; this.minNode_ = null;
this.maxNode_ = null; this.maxNode_ = null;
this.count_ = 0; this.count_ = 0;
}; };
@ -250,24 +255,24 @@ AvlTree.prototype.clear = function() {
* @return {boolean} Whether the tree contains a node with the specified value. * @return {boolean} Whether the tree contains a node with the specified value.
*/ */
AvlTree.prototype.contains = function(value) { AvlTree.prototype.contains = function(value) {
// Assume the value is not in the tree and set this value if it is found // Assume the value is not in the tree and set this value if it is found
var isContained = false; var isContained = false;
// Depth traverse the tree and set isContained if we find the node // Depth traverse the tree and set isContained if we find the node
this.traverse_(function(node) { this.traverse_(function(node) {
var retNode = null; var retNode = null;
if (this.comparator_(node.value, value) > 0) { if (this.comparator_(node.value, value) > 0) {
retNode = node.left; retNode = node.left;
} else if (this.comparator_(node.value, value) < 0) { } else if (this.comparator_(node.value, value) < 0) {
retNode = node.right; retNode = node.right;
} else { } else {
isContained = true; isContained = true;
} }
return retNode; // If null, we'll stop traversing the tree return retNode; // If null, we'll stop traversing the tree
}); });
// Return true if the value is contained in the tree, false otherwise // Return true if the value is contained in the tree, false otherwise
return isContained; return isContained;
}; };
@ -277,7 +282,7 @@ AvlTree.prototype.contains = function(value) {
* @return {number} The number of values stored in the tree. * @return {number} The number of values stored in the tree.
*/ */
AvlTree.prototype.getCount = function() { AvlTree.prototype.getCount = function() {
return this.count_; return this.count_;
}; };
@ -288,7 +293,7 @@ AvlTree.prototype.getCount = function() {
* @return {*} The minimum value contained in the tree. * @return {*} The minimum value contained in the tree.
*/ */
AvlTree.prototype.getMinimum = function() { AvlTree.prototype.getMinimum = function() {
return this.getMinNode_().value; return this.getMinNode_().value;
}; };
@ -299,7 +304,7 @@ AvlTree.prototype.getMinimum = function() {
* @return {*} The maximum value contained in the tree. * @return {*} The maximum value contained in the tree.
*/ */
AvlTree.prototype.getMaximum = function() { AvlTree.prototype.getMaximum = function() {
return this.getMaxNode_().value; return this.getMaxNode_().value;
}; };
@ -311,7 +316,7 @@ AvlTree.prototype.getMaximum = function() {
* @return {number} The height of the tree. * @return {number} The height of the tree.
*/ */
AvlTree.prototype.getHeight = function() { AvlTree.prototype.getHeight = function() {
return this.root_ ? this.root_.height : 0; return this.root_ ? this.root_.height : 0;
}; };
@ -321,11 +326,11 @@ AvlTree.prototype.getHeight = function() {
* @return {Array} An array containing all of the trees values in sorted order. * @return {Array} An array containing all of the trees values in sorted order.
*/ */
AvlTree.prototype.getValues = function() { AvlTree.prototype.getValues = function() {
var ret = []; var ret = [];
this.inOrderTraverse(function(value) { this.inOrderTraverse(function(value) {
ret.push(value); ret.push(value);
}); });
return ret; return ret;
}; };
@ -341,106 +346,106 @@ AvlTree.prototype.getValues = function() {
*/ */
AvlTree.prototype.inOrderTraverse = AvlTree.prototype.inOrderTraverse =
function(func, opt_startValue) { function(func, opt_startValue) {
// If our tree is empty, return immediately // If our tree is empty, return immediately
if (!this.root_) { if (!this.root_) {
return; return;
}
// Depth traverse the tree to find node to begin in-order traversal from
var startNode;
if (opt_startValue) {
this.traverse_(function(node) {
var retNode = null;
if (this.comparator_(node.value, opt_startValue) > 0) {
retNode = node.left;
startNode = node;
} else if (this.comparator_(node.value, opt_startValue) < 0) {
retNode = node.right;
} else {
startNode = node;
}
return retNode; // If null, we'll stop traversing the tree
});
} else {
startNode = this.getMinNode_();
}
// Traverse the tree and call func on each traversed node's value
var node = startNode, prev = startNode.left ? startNode.left : startNode;
while (node != null) {
if (node.left != null && node.left != prev && node.right != prev) {
node = node.left;
} else {
if (node.right != prev) {
if (func(node.value)) {
return;
} }
}
var temp = node;
node = node.right != null && node.right != prev ?
node.right :
node.parent;
prev = temp;
}
}
};
// Depth traverse the tree to find node to begin in-order traversal from
/** var startNode;
* Performs a reverse-order traversal of the tree and calls {@code func} with if (opt_startValue) {
* each traversed node, optionally starting from the largest node with a value this.traverse_(function(node) {
* <= to the specified start value. The traversal ends after traversing the var retNode = null;
* tree's minimum node or when func returns a value that evaluates to true. if (this.comparator_(node.value, opt_startValue) > 0) {
* retNode = node.left;
* @param {Function} func Function to call on each traversed node. startNode = node;
* @param {Object=} opt_startValue If specified, traversal will begin on the } else if (this.comparator_(node.value, opt_startValue) < 0) {
* node with the largest value <= opt_startValue. retNode = node.right;
*/ } else {
AvlTree.prototype.reverseOrderTraverse = startNode = node;
function(func, opt_startValue) { }
// If our tree is empty, return immediately return retNode; // If null, we'll stop traversing the tree
if (!this.root_) { });
return; } else {
} startNode = this.getMinNode_();
// Depth traverse the tree to find node to begin reverse-order traversal from
var startNode;
if (opt_startValue) {
this.traverse_(goog.bind(function(node) {
var retNode = null;
if (this.comparator_(node.value, opt_startValue) > 0) {
retNode = node.left;
} else if (this.comparator_(node.value, opt_startValue) < 0) {
retNode = node.right;
startNode = node;
} else {
startNode = node;
}
return retNode; // If null, we'll stop traversing the tree
}, this));
} else {
startNode = this.getMaxNode_();
}
// Traverse the tree and call func on each traversed node's value
var node = startNode, prev = startNode.right ? startNode.right : startNode;
while (node != null) {
if (node.right != null && node.right != prev && node.left != prev) {
node = node.right;
} else {
if (node.left != prev) {
if (func(node.value)) {
return;
} }
}
var temp = node; // Traverse the tree and call func on each traversed node's value
node = node.left != null && node.left != prev ? var node = startNode, prev = startNode.left ? startNode.left : startNode;
node.left : while (node != null) {
node.parent; if (node.left != null && node.left != prev && node.right != prev) {
prev = temp; node = node.left;
} } else {
} if (node.right != prev) {
}; if (func(node.value)) {
return;
}
}
var temp = node;
node = node.right != null && node.right != prev ?
node.right :
node.parent;
prev = temp;
}
}
};
// /**
// * Performs a reverse-order traversal of the tree and calls {@code func} with
// * each traversed node, optionally starting from the largest node with a value
// * <= to the specified start value. The traversal ends after traversing the
// * tree's minimum node or when func returns a value that evaluates to true.
// *
// * @param {Function} func Function to call on each traversed node.
// * @param {Object=} opt_startValue If specified, traversal will begin on the
// * node with the largest value <= opt_startValue.
// */
// AvlTree.prototype.reverseOrderTraverse =
// function(func, opt_startValue) {
// // If our tree is empty, return immediately
// if (!this.root_) {
// return;
// }
// // Depth traverse the tree to find node to begin reverse-order traversal from
// var startNode;
// if (opt_startValue) {
// this.traverse_(goog.bind(function(node) {
// var retNode = null;
// if (this.comparator_(node.value, opt_startValue) > 0) {
// retNode = node.left;
// } else if (this.comparator_(node.value, opt_startValue) < 0) {
// retNode = node.right;
// startNode = node;
// } else {
// startNode = node;
// }
// return retNode; // If null, we'll stop traversing the tree
// }, this));
// } else {
// startNode = this.getMaxNode_();
// }
// // Traverse the tree and call func on each traversed node's value
// var node = startNode, prev = startNode.right ? startNode.right : startNode;
// while (node != null) {
// if (node.right != null && node.right != prev && node.left != prev) {
// node = node.right;
// } else {
// if (node.left != prev) {
// if (func(node.value)) {
// return;
// }
// }
// var temp = node;
// node = node.left != null && node.left != prev ?
// node.left :
// node.parent;
// prev = temp;
// }
// }
// };
/** /**
@ -461,12 +466,29 @@ AvlTree.prototype.reverseOrderTraverse =
*/ */
AvlTree.prototype.traverse_ = AvlTree.prototype.traverse_ =
function(traversalFunc, opt_startNode, opt_endNode) { function(traversalFunc, opt_startNode, opt_endNode) {
var node = opt_startNode ? opt_startNode : this.root_; var node = opt_startNode ? opt_startNode : this.root_;
var endNode = opt_endNode ? opt_endNode : null; var endNode = opt_endNode ? opt_endNode : null;
while (node && node != endNode) { while (node && node != endNode) {
node = traversalFunc.call(this, node); node = traversalFunc.call(this, node);
} }
}; };
// CPS'ed version of the traverse function
AvlTree.prototype.traverse_k_ =
function(traversalFunc_k, opt_startNode, opt_endNode, k) {
var node = opt_startNode ? opt_startNode : this.root_;
var endNode = opt_endNode ? opt_endNode : null;
var loop = function(node) {
if (node && node != endNode) {
traversalFunc_k.call(this, node, loop);
} else {
k();
}
}
return loop(node);
};
/** /**
@ -481,36 +503,36 @@ AvlTree.prototype.traverse_ =
*/ */
AvlTree.prototype.balance_ = function(node) { AvlTree.prototype.balance_ = function(node) {
this.traverse_(function(node) { this.traverse_(function(node) {
// Calculate the left and right node's heights // Calculate the left and right node's heights
var lh = node.left ? node.left.height : 0; var lh = node.left ? node.left.height : 0;
var rh = node.right ? node.right.height : 0; var rh = node.right ? node.right.height : 0;
// Rotate tree rooted at this node if it is not AVL-tree balanced // Rotate tree rooted at this node if it is not AVL-tree balanced
if (lh - rh > 1) { if (lh - rh > 1) {
if (node.left.right && (!node.left.left || if (node.left.right && (!node.left.left ||
node.left.left.height < node.left.right.height)) { node.left.left.height < node.left.right.height)) {
this.leftRotate_(node.left); this.leftRotate_(node.left);
} }
this.rightRotate_(node); this.rightRotate_(node);
} else if (rh - lh > 1) { } else if (rh - lh > 1) {
if (node.right.left && (!node.right.right || if (node.right.left && (!node.right.right ||
node.right.right.height < node.right.left.height)) { node.right.right.height < node.right.left.height)) {
this.rightRotate_(node.right); this.rightRotate_(node.right);
} }
this.leftRotate_(node); this.leftRotate_(node);
} }
// Recalculate the left and right node's heights // Recalculate the left and right node's heights
lh = node.left ? node.left.height : 0; lh = node.left ? node.left.height : 0;
rh = node.right ? node.right.height : 0; rh = node.right ? node.right.height : 0;
// Set this node's height // Set this node's height
node.height = Math.max(lh, rh) + 1; node.height = Math.max(lh, rh) + 1;
// Traverse up tree and balance parent // Traverse up tree and balance parent
return node.parent; return node.parent;
}, node); }, node);
}; };
@ -522,24 +544,24 @@ AvlTree.prototype.balance_ = function(node) {
* @private * @private
*/ */
AvlTree.prototype.leftRotate_ = function(node) { AvlTree.prototype.leftRotate_ = function(node) {
// Re-assign parent-child references for the parent of the node being removed // Re-assign parent-child references for the parent of the node being removed
if (node.isLeftChild()) { if (node.isLeftChild()) {
node.parent.left = node.right; node.parent.left = node.right;
node.right.parent = node.parent; node.right.parent = node.parent;
} else if (node.isRightChild()) { } else if (node.isRightChild()) {
node.parent.right = node.right; node.parent.right = node.right;
node.right.parent = node.parent; node.right.parent = node.parent;
} else { } else {
this.root_ = node.right; this.root_ = node.right;
this.root_.parent = null; this.root_.parent = null;
} }
// Re-assign parent-child references for the child of the node being removed // Re-assign parent-child references for the child of the node being removed
var temp = node.right; var temp = node.right;
node.right = node.right.left; node.right = node.right.left;
if (node.right != null) node.right.parent = node; if (node.right != null) node.right.parent = node;
temp.left = node; temp.left = node;
node.parent = temp; node.parent = temp;
}; };
@ -550,24 +572,24 @@ AvlTree.prototype.leftRotate_ = function(node) {
* @private * @private
*/ */
AvlTree.prototype.rightRotate_ = function(node) { AvlTree.prototype.rightRotate_ = function(node) {
// Re-assign parent-child references for the parent of the node being removed // Re-assign parent-child references for the parent of the node being removed
if (node.isLeftChild()) { if (node.isLeftChild()) {
node.parent.left = node.left; node.parent.left = node.left;
node.left.parent = node.parent; node.left.parent = node.parent;
} else if (node.isRightChild()) { } else if (node.isRightChild()) {
node.parent.right = node.left; node.parent.right = node.left;
node.left.parent = node.parent; node.left.parent = node.parent;
} else { } else {
this.root_ = node.left; this.root_ = node.left;
this.root_.parent = null; this.root_.parent = null;
} }
// Re-assign parent-child references for the child of the node being removed // Re-assign parent-child references for the child of the node being removed
var temp = node.left; var temp = node.left;
node.left = node.left.right; node.left = node.left.right;
if (node.left != null) node.left.parent = node; if (node.left != null) node.left.parent = node;
temp.right = node; temp.right = node;
node.parent = temp; node.parent = temp;
}; };
@ -579,65 +601,65 @@ AvlTree.prototype.rightRotate_ = function(node) {
* @private * @private
*/ */
AvlTree.prototype.removeNode_ = function(node) { AvlTree.prototype.removeNode_ = function(node) {
// Perform normal binary tree node removal, but balance the tree, starting // Perform normal binary tree node removal, but balance the tree, starting
// from where we removed the node // from where we removed the node
if (node.left != null || node.right != null) { if (node.left != null || node.right != null) {
var b = null; // Node to begin balance from var b = null; // Node to begin balance from
var r; // Node to replace the node being removed var r; // Node to replace the node being removed
if (node.left != null) { if (node.left != null) {
r = this.getMaxNode_(node.left); r = this.getMaxNode_(node.left);
if (r != node.left) { if (r != node.left) {
r.parent.right = r.left; r.parent.right = r.left;
if (r.left) r.left.parent = r.parent; if (r.left) r.left.parent = r.parent;
r.left = node.left; r.left = node.left;
r.left.parent = r; r.left.parent = r;
b = r.parent; b = r.parent;
} }
r.parent = node.parent; r.parent = node.parent;
r.right = node.right; r.right = node.right;
if (r.right) r.right.parent = r; if (r.right) r.right.parent = r;
if (node == this.maxNode_) this.maxNode_ = r; if (node == this.maxNode_) this.maxNode_ = r;
} else { } else {
r = this.getMinNode_(node.right); r = this.getMinNode_(node.right);
if (r != node.right) { if (r != node.right) {
r.parent.left = r.right; r.parent.left = r.right;
if (r.right) r.right.parent = r.parent; if (r.right) r.right.parent = r.parent;
r.right = node.right; r.right = node.right;
r.right.parent = r; r.right.parent = r;
b = r.parent; b = r.parent;
} }
r.parent = node.parent; r.parent = node.parent;
r.left = node.left; r.left = node.left;
if (r.left) r.left.parent = r; if (r.left) r.left.parent = r;
if (node == this.minNode_) this.minNode_ = r; if (node == this.minNode_) this.minNode_ = r;
} }
// Update the parent of the node being removed to point to its replace // Update the parent of the node being removed to point to its replace
if (node.isLeftChild()) { if (node.isLeftChild()) {
node.parent.left = r; node.parent.left = r;
} else if (node.isRightChild()) { } else if (node.isRightChild()) {
node.parent.right = r; node.parent.right = r;
} else { } else {
this.root_ = r; this.root_ = r;
} }
// Balance the tree // Balance the tree
this.balance_(b ? b : r); this.balance_(b ? b : r);
} else {
// If the node is a leaf, remove it and balance starting from its parent
if (node.isLeftChild()) {
this.special = 1;
node.parent.left = null;
if (node == this.minNode_) this.minNode_ = node.parent;
this.balance_(node.parent);
} else if (node.isRightChild()) {
node.parent.right = null;
if (node == this.maxNode_) this.maxNode_ = node.parent;
this.balance_(node.parent);
} else { } else {
this.clear(); // If the node is a leaf, remove it and balance starting from its parent
if (node.isLeftChild()) {
this.special = 1;
node.parent.left = null;
if (node == this.minNode_) this.minNode_ = node.parent;
this.balance_(node.parent);
} else if (node.isRightChild()) {
node.parent.right = null;
if (node == this.maxNode_) this.maxNode_ = node.parent;
this.balance_(node.parent);
} else {
this.clear();
}
} }
}
}; };
@ -651,21 +673,21 @@ AvlTree.prototype.removeNode_ = function(node) {
* @private * @private
*/ */
AvlTree.prototype.getMinNode_ = function(opt_rootNode) { AvlTree.prototype.getMinNode_ = function(opt_rootNode) {
if (!opt_rootNode) { if (!opt_rootNode) {
return this.minNode_; return this.minNode_;
}
var minNode = opt_rootNode;
this.traverse_(function(node) {
var retNode = null;
if (node.left) {
minNode = node.left;
retNode = node.left;
} }
return retNode; // If null, we'll stop traversing the tree
}, opt_rootNode);
return minNode; var minNode = opt_rootNode;
this.traverse_(function(node) {
var retNode = null;
if (node.left) {
minNode = node.left;
retNode = node.left;
}
return retNode; // If null, we'll stop traversing the tree
}, opt_rootNode);
return minNode;
}; };
@ -679,21 +701,21 @@ AvlTree.prototype.getMinNode_ = function(opt_rootNode) {
* @private * @private
*/ */
AvlTree.prototype.getMaxNode_ = function(opt_rootNode) { AvlTree.prototype.getMaxNode_ = function(opt_rootNode) {
if (!opt_rootNode) { if (!opt_rootNode) {
return this.maxNode_; return this.maxNode_;
}
var maxNode = opt_rootNode;
this.traverse_(function(node) {
var retNode = null;
if (node.right) {
maxNode = node.right;
retNode = node.right;
} }
return retNode; // If null, we'll stop traversing the tree
}, opt_rootNode);
return maxNode; var maxNode = opt_rootNode;
this.traverse_(function(node) {
var retNode = null;
if (node.right) {
maxNode = node.right;
retNode = node.right;
}
return retNode; // If null, we'll stop traversing the tree
}, opt_rootNode);
return maxNode;
}; };
@ -708,19 +730,19 @@ AvlTree.prototype.getMaxNode_ = function(opt_rootNode) {
* @constructor * @constructor
*/ */
AvlTree.Node = function(value, opt_parent) { AvlTree.Node = function(value, opt_parent) {
/** /**
* The value stored by the node. * The value stored by the node.
* *
* @type {*} * @type {*}
*/ */
this.value = value; this.value = value;
/** /**
* The node's parent. Null if the node is the root. * The node's parent. Null if the node is the root.
* *
* @type {AvlTree.Node} * @type {AvlTree.Node}
*/ */
this.parent = opt_parent ? opt_parent : null; this.parent = opt_parent ? opt_parent : null;
}; };
@ -756,7 +778,7 @@ AvlTree.Node.prototype.height = 1;
* child of its parent. * child of its parent.
*/ */
AvlTree.Node.prototype.isRightChild = function() { AvlTree.Node.prototype.isRightChild = function() {
return !!this.parent && this.parent.right == this; return !!this.parent && this.parent.right == this;
}; };
@ -768,5 +790,5 @@ AvlTree.Node.prototype.isRightChild = function() {
* child of its parent. * child of its parent.
*/ */
AvlTree.Node.prototype.isLeftChild = function() { AvlTree.Node.prototype.isLeftChild = function() {
return !!this.parent && this.parent.left == this; return !!this.parent && this.parent.left == this;
}; };