web/avl.js

215 lines
5.6 KiB
JavaScript
Raw Normal View History

function balanceFactor(node) {
if (!node) {
return 0;
}
let [left, right] = [nodeRank(node.left), nodeRank(node.right)];
return right - left;
}
function updateRank(node) {
let [left, right] = [nodeRank(node.left), nodeRank(node.right)];
node.rank = 1 + Math.max(left, right);
}
class AVLTree extends RankedTree {
isCorrectNode(node, recursive) {
if (!node) {
return true;
}
let differences = nodeDifferences(node).sort();
if (
(!differences.equals([1, 1]) && !differences.equals([1, 2])) ||
node.rank != 1 + Math.max(...differences)
) {
return false;
}
recursive = recursive ?? true;
return (
!recursive ||
(this.isCorrectNode(node.left) && this.isCorrectNode(node.right))
);
}
fix0Child(x, y, z, rotatingAroundRoot, rotateLeft, rotateRight) {
let newRoot = x.parent;
if (!y || nodeDifference(y) == 2) {
newRoot = rotateRight(z);
if (rotatingAroundRoot) {
this.root = newRoot;
}
this.record("Fixing 0-child by single rotation: by z", z, newRoot);
z.demote();
this.record("Fixing 0-child by single rotation: demoting z", z);
} else if (nodeDifference(y) == 1) {
let intermediateRoot = rotateLeft(x);
this.record(
"Fixing 0-child by double-rotation: first rotation by x",
x,
intermediateRoot
);
newRoot = rotateRight(z);
if (rotatingAroundRoot) {
this.root = newRoot;
}
this.record(
"Fixing 0-child by double-rotation: second rotation by z",
z,
newRoot
);
y.promote();
this.record("Fixing 0-child by double-rotation: promoting y", y);
x.demote();
this.record("Fixing 0-child by double-rotation: demoting x", x);
z.demote();
this.record("Fixing 0-child by double-rotation: demoting z", z);
}
}
insertRebalance(x) {
let diffs = nodeDifferences(x.parent).sort();
while (x.parent && diffs.equals([0, 1])) {
x.parent.promote();
this.record(
"Insertion rebalance: promoting (0, 1) parent",
x.parent
);
x = x.parent;
diffs = nodeDifferences(x.parent).sort();
}
if (!x.parent) {
return;
}
let rotatingAroundRoot = x.parent.parent == null;
let rankDifference = nodeDifference(x);
if (rankDifference != 0) {
return;
}
let xParent = x.parent;
if (rankDifference == 0 && x.parent.left === x) {
this.fix0Child(
x,
x.right,
xParent,
rotatingAroundRoot,
rotateLeft,
rotateRight
);
} else if (rankDifference == 0 && x.parent.right === x) {
this.fix0Child(
x,
x.left,
xParent,
rotatingAroundRoot,
rotateRight,
rotateLeft
);
}
}
deleteRotate(x, y, leaning, rotatingAroundRoot, rotateLeft, rotateRight) {
let newRoot = x;
let factor = balanceFactor(y);
switch (factor) {
case 0:
case leaning:
newRoot = rotateLeft(x);
break;
default:
let intermediateRoot = rotateRight(y);
this.record(
"AVL deletion, fixing by double-rotation: by y",
y,
intermediateRoot
);
newRoot = rotateLeft(x);
break;
}
if (rotatingAroundRoot) {
this.root = newRoot;
}
this.record("AVL deletion, fixing by rotation by x", x, newRoot);
[newRoot.left, newRoot.right, newRoot]
.filter((x) => x)
.forEach((n) => {
updateRank(n);
this.record("Updating rank of nodes affected by rotations", n);
});
return factor != 0;
}
deleteFixup(x, parent) {
let factor = balanceFactor(x);
switch (factor) {
case 0:
updateRank(x);
this.record(
"Updating rank of node affected by the propagation of delete",
x
);
return true;
case -1:
case 1:
return false;
}
let rotatingAroundRoot = x.parent == null;
let [z, leaning, toLeft, toRight] = [
x.left,
-1,
rotateRight,
rotateLeft,
];
if (factor == 2) {
[z, leaning, toLeft, toRight] = [
x.right,
1,
rotateLeft,
rotateRight,
];
}
return this.deleteRotate(
x,
z,
leaning,
rotatingAroundRoot,
toLeft,
toRight
);
}
deleteRebalance(node, parent) {
if (!node && !parent) {
return;
}
if (!node) {
[node, parent] = [parent, parent.parent];
}
while (node && this.deleteFixup(node, parent)) {
[node, parent] = [parent, parent ? parent.parent : null];
}
}
}