@foxglove/avl/dist/AVLNode.js

Adelson-Velsky-Landis (AVL) self-balancing binary trees in TypeScript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.printNodes = exports.prevNode = exports.nextNode = exports.rotateRight = exports.rotateLeft = void 0;
/**
 * Single left rotation
 */
function rotateLeft(node) {
    const rightNode = node.right;
    node.right = rightNode.left;
    if (rightNode.left) {
        rightNode.left.parent = node;
    }
    rightNode.parent = node.parent;
    if (rightNode.parent) {
        if (rightNode.parent.left === node) {
            rightNode.parent.left = rightNode;
        }
        else {
            rightNode.parent.right = rightNode;
        }
    }
    node.parent = rightNode;
    rightNode.left = node;
    node.balanceFactor += 1;
    if (rightNode.balanceFactor < 0) {
        node.balanceFactor -= rightNode.balanceFactor;
    }
    rightNode.balanceFactor += 1;
    if (node.balanceFactor > 0) {
        rightNode.balanceFactor += node.balanceFactor;
    }
    return rightNode;
}
exports.rotateLeft = rotateLeft;
/**
 * Single right rotation
 */
function rotateRight(node) {
    const leftNode = node.left;
    node.left = leftNode.right;
    if (node.left) {
        node.left.parent = node;
    }
    leftNode.parent = node.parent;
    if (leftNode.parent) {
        if (leftNode.parent.left === node) {
            leftNode.parent.left = leftNode;
        }
        else {
            leftNode.parent.right = leftNode;
        }
    }
    node.parent = leftNode;
    leftNode.right = node;
    node.balanceFactor -= 1;
    if (leftNode.balanceFactor > 0) {
        node.balanceFactor -= leftNode.balanceFactor;
    }
    leftNode.balanceFactor -= 1;
    if (node.balanceFactor < 0) {
        leftNode.balanceFactor += node.balanceFactor;
    }
    return leftNode;
}
exports.rotateRight = rotateRight;
/**
 * Return the node immediately after the given node in the in-order traversal
 */
function nextNode(node) {
    let curNode = node;
    let successor = node;
    if (successor.right) {
        successor = successor.right;
        while (successor.left) {
            successor = successor.left;
        }
    }
    else {
        successor = curNode.parent;
        while (successor && successor.right === curNode) {
            curNode = successor;
            successor = successor.parent;
        }
    }
    return successor;
}
exports.nextNode = nextNode;
/**
 * Return the node immediately before the given node in the in-order traversal
 */
function prevNode(node) {
    let curNode = node;
    let predecessor = node;
    if (predecessor.left) {
        predecessor = predecessor.left;
        while (predecessor.right) {
            predecessor = predecessor.right;
        }
    }
    else {
        predecessor = curNode.parent;
        while (predecessor && predecessor.left === curNode) {
            curNode = predecessor;
            predecessor = predecessor.parent;
        }
    }
    return predecessor;
}
exports.prevNode = prevNode;
/**
 * Prints tree horizontally
 */
function printNodes(root, printEntry = (n) => String(n[0])) {
    const out = [];
    row(root, "", true, (v) => out.push(v), printEntry);
    return out.join("");
}
exports.printNodes = printNodes;
/**
 * Prints a level of the tree
 */
function row(root, prefix, isTail, callback, printEntry) {
    if (root) {
        callback(`${prefix}${isTail ? "└── " : "├── "}${printEntry([root.key, root.value])}\n`);
        const indent = prefix + (isTail ? "    " : "│   ");
        if (root.left) {
            row(root.left, indent, false, callback, printEntry);
        }
        if (root.right) {
            row(root.right, indent, true, callback, printEntry);
        }
    }
}
//# sourceMappingURL=AVLNode.js.map