function BinaryTree(value, left = null, right = null) { // Деревом, по сути, будет узел со сзначением и двумя детьми, которые по дефолту null
    return function(){
        let getValue = () => value;
        let getLeft = () => left;
        let getRight = () => right;
        let setLeft = (subTree) => left = subTree;
        let setRight = (subTree) => right = subTree;
        let set = (x) => {
            if (getValue() === x) {
                return;
            }
            if (x < getValue()) {
                if (getLeft() !== null) {
                    return getLeft().set(x);
                } else {
                    setLeft(new BinaryTree(x));
                    return;
                }
            } else {
                if (getRight() !== null) {
                    return getRight().set(x);
                } else {
                    setRight(new BinaryTree(x));
                    return;
                }
            }
        };
        return{
            getValue: getValue,
            getLeft: getLeft,
            getRight: getRight,
            set: set
        };
    }();
}

let treee = new BinaryTree(4);
console.log(treee.getValue());
treee.set(6);
console.log(treee.toString());

BinaryTree.prototype.toString = function () {  // Если имеются дети, то есть они не null'ы, то мы добавляем их к выводу
    let leftPart = this.getLeft() === null ? "" : (this.getLeft().toString() + ' '); // Пробелы добавляем на этом этапе, а не на этапе return'а, шобы не было лишних пробелов при отсутствии детей
    let rightPart = this.getRight() === null ? "" : (' ' + this.getRight().toString());
    return leftPart + this.getValue() + rightPart; // В чём идея: часто бинарные деревья являются деревьсями поиска, так что
    // значение в левом ребёнке < значение в родителе < значение в правом ребёнке
    // Если нас попросят нати х, то мы смотрим в узел, если не совпадает, то сравниваем
    // если х меньше значения в узле, обращаемся к левому ребёнку, иначе - к правому.
    // Так вот. Если иходить из того, что дерево имеет такой вид, то данный способ выведет значения в дереве в отсортированном порядке
    // Я хз, чё именно в этом задании хочут
};

function printTree(binaryTree, depth = 0) { // Эта версия отражает иерархию. Глубина имеет дефолтное значение, которое ей присвоится, если мы не передадим другое
    let dots = ""; // Мне кажется, точки маленько помогут осознать, кто чей ребёнок
    for (let i = 0; i < depth; i++) {
        dots += '.';
    }
    console.log(dots, binaryTree.getValue()); //Сначала печатаем родителя, а потом двух детей
    if (binaryTree.getLeft() !== null) printTree(binaryTree.getLeft(), depth + 1); // Тут не уверен в правильности проверки на undefined
    if (binaryTree.getRight() !== null) printTree(binaryTree.getRight(), depth + 1);
}

function printTree1(binaryTree) {
    console.log(binaryTree.toString());
}

// Пример использования кода:
let tree =
new BinaryTree(7,
     new BinaryTree(4,
        new BinaryTree(2),
        new BinaryTree(6)),
    new BinaryTree(11)
    );

tree.set(17);
// Тут как раз дерево поиска, шоб продемонстрировать отсортированность вывода
/*
                7
              /  \
             4    11
           /  \
          2    6
 */
printTree(tree);
printTree1(tree);