BinarySearchTree.ts

class TreeNode {
    value: number;
    left: TreeNode | null;
    right: TreeNode | null;

    constructor(value: number) {
        this.value = value,
            this.left = null;
        this.right = null;
    }
}

export class BinarySearchTree {
    root: TreeNode | null;

    constructor() {
        this.root = null;
    }

    insert(value: number) {
        const newNode = new TreeNode(value);

        if (this.root === null) {
            this.root = newNode;
        }
        else {
            this.insertNode(this.root, newNode)
        }
    }

    insertNode(node: TreeNode, newNode: TreeNode) {
        if (newNode.value < node.value) {
            if (node.left === null) {
                node.left = newNode;
            }
            else {
                this.insertNode(node.left, newNode);
            }
        }
        else {
            if (node.right === null) {
                node.right = newNode;
            }
            else {
                this.insertNode(node.right, newNode)
            }
        }
    }

    remove(value: number) {
        this.root = this.removeNode(this.root, value);
    }

    removeNode(node: TreeNode | null, key: number) : null | TreeNode {
        if (node === null) {
            return null;
        }
        else if (key < node.value) {
            node.left = this.removeNode(node.left, key);
            return node;
        }
        else if (key > node.value) {
            node.left = this.removeNode(node.right, key);
            return node;
        }
        else {
            if (node.left === null && node.right === null) {
                node = null;
                return node;
            }

            if (node.left === null) {
                node = node.right;
                return node;
            }

            else if (node.right === null) {
                node = node.left;
                return node;
            }
        }

        const aux = this.findMinNode(node.right);

        node.value = aux.value;

        node.right = this.removeNode(node.right, aux.value);
        return node;
    }

    inorder(node: TreeNode | null) {
        if (node !== null) {
            this.inorder(node.left);
            console.log(node.value);
            this.inorder(node.right);
        }
    }

    preorder(node: TreeNode | null) {
        if (node !== null) {
            console.log(node.value);
            this.preorder(node.left);
            this.preorder(node.right);
        }
    }

    postorder(node: TreeNode | null) {
        if (node !== null) {
            this.postorder(node.left);
            this.postorder(node.right);
            console.log(node.value);
        }
    }

    findMinNode(node: TreeNode | null | undefined): TreeNode {
        if (node?.left === null)
            return node;
        else
            return this.findMinNode(node?.left);
    }

    getRootNode() : TreeNode | null {
        return this.root;
    }

    search(node: TreeNode | null, value: number) : TreeNode | null {
        if (node === null) {
            return null;
        }
        else if (value < node.value) {
            return this.search(node.left, value);
        }
        else if (value > node.value) {
            return this.search(node.right, value);
        }
        else
            return node;
    }
}