JS实现二叉搜索树

    function Tree(){
        var Node = function(key) {
            this.key = key;
            this.left = null;
            this.right = null;
        }
        var root = null;

        //插入结点
        this.insert = function(key) {
            var newNode = new Node(key);
            if(root === null) {
                root = node;
            }else{
                insertNode(root, newNode);
            }
        }
        var insertNode = function(root, newNode){
            if(root.key < newNode.key) {
                if(root.left === null) {
                    root.left = newNode;
                }else{
                    insertNode(root.left, newNode);
                }
            } else {
                if(root.right === null) {
                    root.right = newNode;
                }else {
                    insertNode(root.right, newNode);
                }
            }
        };

        //中序遍历
        this.inOrderTraverse = function(callback) {
            inOrderTraverseNode(root, callback);
        }
        var inOrderTraverseNode = function(node, callback) {
            if(node !== null) {
                inOrderTraverseNode(node.left, callback);
                callback(node.key);
                inOrderTraverseNode(node.right, callback);
            }
        }

        //先序遍历
        this.preOrderTraverse = function(callback){
            preOrderTraverseNode(root, callback);
        }
        var preOrderTraverseNode = function(node, callback) {
            if(node !== null) {
                callback(node.key);
                preOrderTraverseNode(node.left, callback);
                preOrderTraverseNode(node.right, callback);
            }
        };

        //后序遍历
        this.postOrderTraverse = function(callback){
            postOrderTraverseNode(root, callback);
        };
        var postOrderTraverseNode = function(node, callback) {
            if(node !== null) {
                postOrderTraverseNode(node.left);
                postOrderTraverseNode(node.right);
                callback(node.key);
            }
        };

        //查找树中的最小值
        this.min = function() {
            return minNode(root);
        }
        var minNode = function(node) {
            if(node !== null) {
                while(node && node.left !== null) {
                    node = node.left;
                }
                return node.key;
            }
            return null;
        };

        //搜索一个特定的值
        this.search = function(key) {
            searchNode(root, key);
        }
        var searchNode = function(node, key) {
            if(node === null) {
                return false;
            }
            if(key < node.key) {
                searchNode(node.left, key);
            } else if(key > node.key) {
                searchNode(node.right, key);
            } else {
                return true;
            }
        };

        //移除一个节点
        this.remove = function(key) {
            removeNode(root, key);
        };
        var removeNode = function(node, key) {
            if(node === null) {
                return false;
            }
            if(key < node.left) {
                removeNode(node.left, key);
            }else if(key > node.right) {
                removeNode(node.right, key);
            }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;
                }
                //第三种情况——有两个子节点的节点
                var aux = findMinNode(node.right);
                node.key = aux.key;
                removeNode(node.right, aux.key);
                return node;
            }
        };
        //找到最小节点并返回
        var findMinNode = function(node){
            if(node) {
                while(node && node.left !== null) {
                    node = node.left;
                }
                return node;
            }
            return false;
        };

    }