js 实现二叉搜索树

js 实现二叉搜索树

//二叉搜索树
function BinaryTree() {
    let root = null;         
    function Node(key) {
        this.key = key;
        this.left = null;
        this.right = null;
    }
    function insertNode (node,newNode) {
        if(newNode.key < root.key) {
            if(node.left === null) {
                node.left = newNode;
            }else {
                insertNode(node.left,newNode);
            }
        }else {
            if(node.right === null) {
                node.right = newNode;
            }else {
                insertNode(node.right,newNode);
            }
        }
    }
    this.insert = function(key) {
        let node = new Node(key);
        if(root === null) {
            root = node;
        }else {
            insertNode(root,node)
        }
        return node;
    }
    function searchNode(node,key) {
        if(node) {
            if(key < node.key) {
                return searchNode(node.left,key);
            }else if(key > node.key) {
                return searchNode(node.right,key);
            }else {
                return true;
            }
        }else {
            return false;
        }
    }
    this.search = function(key) {
        return searchNode(root,key);
    }
    function inOrderT(node,callback) {
        if(node) {
            inOrderT(node.left,callback);
            callback(node.key);
            inOrderT(node.right,callback);
        }
    }
    function printNode(value) {
        console.log(value)
    }
    this.inOrderT = function() {
        return inOrderT(root,printNode)
    }
    this.preOrderT = function() {

    }
    this.postOrderT = function() {

    }
    function minNode (node) {
        if(node) {
            while(node && node.left) {
                node = node.left;
            }
            return node.key;
        }
        return null;
    }
    this.min = function() {
        return minNode(root);
    }
    function maxNode (node) {
        if(node) {
            while(node.right && node) {
                node = node.right;
            }
            return node.key;
        }
        return null;
    }
    this.max = function() {
        return maxNode(root);
    }
    function removeNode(node,key) {
        if(node == null) {
            return null;
        }
        if(key < node.key) {
            node.left = removeNode(node.left,key);
            return node;
        }else if(key > node.key) {
            node.right = 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;
            }
            if(node.right === null) {
                node = node.left;
                return node;
            }
            let aux = findMinNode(node.right);
            node.key = aux.key;
            node.right = removeNode(node.right,aux.key);
            return node;
        }
    }
    function findMinNode(node) {
        if(node) {
            while(node && node.right) {
                node = node.right;
            }
            return node;
        }
    }
    this.remove= function(key) {
        root = removeNode(root,key);
        return true;
    }
    this.print = function() {
        return root;
    }

}    
let tree = new BinaryTree();
tree.insert(11);
tree.insert(7);
tree.insert(15);
tree.insert(5);
tree.insert(9);
tree.insert(13);
tree.insert(12);
tree.insert(3);
tree.insert(6);
tree.insert(8);
tree.insert(10);
tree.insert(12);
tree.insert(14);
tree.insert(18);
tree.insert(25);

// 未完成版...
function BinaryTree(root) {
    this.root = root;
    root.left = null;
    root.right = null;
}
function insertNode(root,key) {
    if(root < key) {
        if(root.left == null) {
            root.left = key;
        }
    }
}
BinaryTree.prototype.insert = function(key) {
    if(key < root) {
        if(root.left == null) {
            root.left = key;
        }else {
            insertNode(root.left,key);
        }
    }else {
        if(root.right == null) {
            root.right = key;
        }else {
            inserNode(root.right,key);
        }
    }

}
BinaryTree.prototype.min = function() {
    return findMin(this.root);
}
BinaryTree.prototype.max = function() {
    return findMax(this.root);
}
BinaryTree.prototype.search = function(key) {

}