doubly-linked-list-typed/dist/data-structures/tree/tree.js

Doubly Linked List

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.TreeNode = void 0;
class TreeNode {
    /**
     * The constructor function initializes a TreeNode object with a key, optional value, and optional
     * children.
     * @param {string} key - A string representing the key of the tree node.
     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
     * value associated with the node. If no value is provided, it defaults to `undefined`.
     * @param {TreeNode<V>[]} [children] - The `children` parameter is an optional array of `TreeNode<V>`
     * objects. It represents the child nodes of the current node. If no children are provided, the
     * default value is an empty array.
     */
    constructor(key, value, children) {
        this._key = key;
        this._value = value || undefined;
        if (children)
            this._children = children;
    }
    /**
     * The function returns the value of the protected variable _key.
     * @returns The value of the `_key` property, which is a string.
     */
    get key() {
        return this._key;
    }
    /**
     * The above function sets the value of a protected variable called "key".
     * @param {string} value - The value parameter is a string that represents the value to be assigned
     * to the key.
     */
    set key(value) {
        this._key = value;
    }
    /**
     * The function returns the value stored in a variable, or undefined if the variable is empty.
     * @returns The value of the variable `_value` is being returned.
     */
    get value() {
        return this._value;
    }
    /**
     * The function sets the value of a variable.
     * @param {V | undefined} value - The parameter "value" is of type "V | undefined", which means it
     * can accept a value of type "V" or it can be undefined.
     */
    set value(value) {
        this._value = value;
    }
    /**
     * The function returns an array of TreeNode objects or undefined.
     * @returns The `children` property is being returned. It is of type `TreeNode<V>[] | undefined`,
     * which means it can either be an array of `TreeNode<V>` objects or `undefined`.
     */
    get children() {
        return this._children;
    }
    /**
     * The function sets the value of the children property of a TreeNode object.
     * @param {TreeNode<V>[] | undefined} value - The value parameter is of type TreeNode<V>[] |
     * undefined. This means that it can accept an array of TreeNode objects or undefined.
     */
    set children(value) {
        this._children = value;
    }
    /**
     * The function `addChildren` adds one or more child nodes to the current node.
     * @param {TreeNode<V> | TreeNode<V>[]} children - The `children` parameter can be either a single
     * `TreeNode<V>` object or an array of `TreeNode<V>` objects.
     */
    addChildren(children) {
        if (!this._children) {
            this._children = [];
        }
        if (children instanceof TreeNode) {
            this._children.push(children);
        }
        else {
            this._children = this._children.concat(children);
        }
    }
    /**
     * The function `getHeight()` calculates the maximum depth of a tree structure by performing a
     * breadth-first search.
     * @returns the maximum depth or height of the tree.
     */
    getHeight() {
        let maxDepth = 0;
        if (this) {
            const bfs = (node, level) => {
                if (level > maxDepth) {
                    maxDepth = level;
                }
                const { _children } = node;
                if (_children) {
                    for (let i = 0, len = _children.length; i < len; i++) {
                        bfs(_children[i], level + 1);
                    }
                }
            };
            bfs(this, 0);
        }
        return maxDepth;
    }
}
exports.TreeNode = TreeNode;