| Path : /var/www/html/tool-ob/ToolsPortal/node_modules/binaryheap/ |
|
B-Con CMD Config cPanel C-Rdp D-Log Info Jump Mass Ransom Symlink vHost Zone-H |
| Current File : /var/www/html/tool-ob/ToolsPortal/node_modules/binaryheap/binaryheap.js |
// Copyright 2012 Timothy J Fontaine <tjfontaine@gmail.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE
'use strict';
var assert = require('assert');
var Heap = function(min) {
this.length = 0;
this.root = undefined;
if (min) {
this._comparator = this._smallest;
} else {
this._comparator = this._largest;
}
};
Heap.init = function(obj, key) {
obj._parent = null;
obj._left = null;
obj._right = null;
obj._key = key;
return obj;
};
Heap.prototype.count = function (node) {
if (!node) return 0;
var c = 1;
c += this.count(node._left);
c += this.count(node._right);
return c;
};
Heap.prototype.insert = function(obj, key) {
var insert, node;
this.length += 1;
node = Heap.init(obj, key);
if (!this.root) {
this.root = node;
} else {
insert = this._last();
node._parent = insert;
if (!insert._left)
insert._left = node;
else
insert._right = node;
this._up(node);
}
this._head();
return node;
};
Heap.prototype.pop = function() {
var ret, last;
if (!this.root)
return null;
return this.remove(this.root);
};
Heap.prototype.remove = function(node) {
var ret, last;
ret = node;
last = this._last();
if (last._right)
last = last._right;
else
last = last._left;
this.length -= 1;
if (!last) {
if (ret == this.root)
this.root = null;
return ret;
}
if (ret == last) {
if (ret._parent._left == node)
ret._parent._left = null;
else
ret._parent._right = null;
last = ret._parent;
ret._parent = null;
} else if (!ret._left && !ret._right) {
// we're trying to remove an element without any children and its not the last
// move the last under its parent and heap-up
if (last._parent._left == last) last._parent._left = null;
else last._parent._right = null;
if (ret._parent._left == ret) ret._parent._left = last;
else ret._parent._right = last;
last._parent = ret._parent;
ret._parent = null;
// TODO in this case we shouldn't later also do a down, but it should only visit once
this._up(last);
} else {
this._delete_swap(ret, last);
}
if (ret == this.root)
this.root = last;
this._down(last);
this._head();
return ret;
};
// TODO this probably isn't the most efficient way to ensure that we're always
// at the root of the tree, but it works for now
Heap.prototype._head = function() {
if (!this.root)
return;
var tmp = this.root;
while (tmp._parent) {
tmp = tmp._parent;
}
this.root = tmp;
};
// TODO is there a more efficient way to store this instead of an array?
Heap.prototype._last = function() {
var path, pos, mod, insert;
pos = this.length;
path = [];
while (pos > 1) {
mod = pos % 2;
pos = Math.floor(pos / 2);
path.push(mod);
}
insert = this.root;
while (path.length > 1) {
pos = path.pop();
if (pos === 0)
insert = insert._left;
else
insert = insert._right;
}
return insert;
};
Heap.prototype._swap = function(a, b) {
var cleft, cright, tparent;
cleft = b._left;
cright = b._right;
if (a._parent) {
if (a._parent._left == a) a._parent._left = b;
else a._parent._right = b;
}
b._parent = a._parent;
a._parent = b;
// This assumes direct descendents
if (a._left == b) {
b._left = a;
b._right = a._right;
if (b._right) b._right._parent = b;
} else {
b._right = a;
b._left = a._left;
if (b._left) b._left._parent = b;
}
a._left = cleft;
a._right = cright;
if (a._left) a._left._parent = a;
if (a._right) a._right._parent = a;
assert.notEqual(a._parent, a, "A shouldn't refer to itself");
assert.notEqual(b._parent, b, "B shouldn't refer to itself");
};
Heap.prototype._delete_swap = function(a, b) {
if (a._left != b) b._left = a._left;
if (a._right != b) b._right = a._right;
if (b._parent._left == b) b._parent._left = null;
else b._parent._right = null;
if (a._parent) {
if (a._parent._left == a) a._parent._left = b;
else a._parent._right = b;
}
b._parent = a._parent;
if (b._left) b._left._parent = b;
if (b._right) b._right._parent = b;
a._parent = null;
a._left = null;
a._right = null;
};
Heap.prototype._smallest = function(heap) {
var small = heap;
if (heap._left && heap._key > heap._left._key) {
small = heap._left;
}
if (heap._right && small._key > heap._right._key) {
small = heap._right;
}
return small;
};
Heap.prototype._largest = function(heap) {
var large = heap;
if (heap._left && heap._key < heap._left._key) {
large = heap._left;
}
if (heap._right && large._key < heap._right._key) {
large = heap._right;
}
return large;
};
Heap.prototype._up = function(node) {
if (!node || !node._parent)
return;
var next = this._comparator(node._parent);
if (next != node._parent) {
this._swap(node._parent, node);
this._up(node);
}
};
Heap.prototype._down = function(node) {
if (!node)
return;
var next = this._comparator(node);
if (next != node) {
this._swap(node, next);
this._down(node);
}
};
var util = require('util');
Heap.prototype.print = function(stream) {
stream.write('digraph {\n');
Heap._print(this.root, stream);
stream.write('}\n');
};
Heap._print = function(heap, stream) {
if (!heap) return;
if (heap._left) {
stream.write(util.format('' + heap._key, '->', heap._left._key, '\n'));
Heap._print(heap._left, stream);
}
if (heap._right) {
stream.write(util.format('' + heap._key, '->', heap._right._key, '\n'));
Heap._print(heap._right, stream);
}
};
module.exports = Heap;