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

132
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
// light edits to flatten the namespace from goog.structs to just
// AvlTree.
// edits to flatten the namespace from goog.structs to just
// AvlTree, commented out inorderTraverse and reverseOrderTraverse.
//
// I'm considering changing the code to work with CPSed control flow.
//
// ----------------------------------------------------------------------
// Original license follows:
// ----------------------------------------------------------------------
@ -386,61 +391,61 @@ AvlTree.prototype.inOrderTraverse =
};
/**
* 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;
}
// /**
// * 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_();
}
// // 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;
}
}
};
// // 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;
// }
// }
// };
/**
@ -469,6 +474,23 @@ AvlTree.prototype.traverse_ =
};
// 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);
};
/**
* Ensures that the specified node and all its ancestors are balanced. If they
* are not, performs left and right tree rotations to achieve a balanced