typescript-algorithms-and-datastructures/dist/RadixTree.js

Useful algorithms and Data structures written in typescript.

(function (factory) {
    if (typeof module === "object" && typeof module.exports === "object") {
        var v = factory(require, exports);
        if (v !== undefined) module.exports = v;
    }
    else if (typeof define === "function" && define.amd) {
        define(["require", "exports", "./RadixTreeNode"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    const RadixTreeNode_1 = require("./RadixTreeNode");
    class RadixTree {
        constructor() {
            this.root = new RadixTreeNode_1.RadixTreeNode("", null);
        }
        insert(word, value) {
            let currentNode = this.root;
            let cumulatedWord = "";
            while (true) {
                const sufix = word.substr(cumulatedWord.length);
                const nextNode = currentNode.selectNextNodeFromPrefix(sufix);
                if (nextNode === null) {
                    if (currentNode.isLeaf()) {
                        currentNode.addChild(new RadixTreeNode_1.RadixTreeNode("", currentNode.value));
                        currentNode.addChild(new RadixTreeNode_1.RadixTreeNode(sufix, value));
                        currentNode.value = null;
                    }
                    else {
                        let nodeToBeSplitted = currentNode.getNodeWithSharedPrefix(sufix);
                        if (nodeToBeSplitted === null) {
                            currentNode.addChild(new RadixTreeNode_1.RadixTreeNode(sufix, value));
                        }
                        else {
                            nodeToBeSplitted.splitNode(sufix);
                            currentNode = nodeToBeSplitted;
                            cumulatedWord += nodeToBeSplitted.word;
                            continue;
                        }
                    }
                    break;
                }
                else {
                    currentNode = nextNode;
                    cumulatedWord += nextNode.word;
                }
            }
        }
        contains(word) {
            let currentNode = this.root;
            let cumulatedWord = "";
            while (currentNode !== null && !currentNode.isLeaf() && cumulatedWord.length <= word.length) {
                const sufix = word.substr(cumulatedWord.length);
                const nextNode = currentNode.selectNextNodeFromPrefix(sufix);
                if (nextNode !== null) {
                    currentNode = nextNode;
                    cumulatedWord += nextNode.word;
                }
                else {
                    currentNode = null;
                }
            }
            return (currentNode !== null && currentNode.isLeaf() && cumulatedWord.length === word.length);
        }
        get(word) {
            let currentNode = this.root;
            let cumulatedWord = "";
            while (currentNode !== null && !currentNode.isLeaf() && cumulatedWord.length <= word.length) {
                const sufix = word.substr(cumulatedWord.length);
                const nextNode = currentNode.selectNextNodeFromPrefix(sufix);
                if (nextNode !== null) {
                    currentNode = nextNode;
                    cumulatedWord += nextNode.word;
                }
                else {
                    currentNode = null;
                }
            }
            if (currentNode !== null && currentNode.isLeaf() && cumulatedWord.length === word.length) {
                return currentNode.value;
            }
            else {
                return null;
            }
        }
    }
    exports.RadixTree = RadixTree;
});
//# sourceMappingURL=RadixTree.js.map