关于js二叉树

function BinaryTree(){
    var Node = function(data){
        this.data = data;
        this.right = null;
        this.left = null;
    }
    this._root = null;
    
    // 插入(使用循环的方式  更推荐这种方法，效率高)
    this.insert = function(data){
        if(!this._root){
            this._root = new Node(data);
        }else{
            let curNode = this._root;
            while(curNode){
                if(data < curNode.data){
                    if(curNode.left === null){
                        curNode.left = new Node(data);
                        break;
                    }else{
                        curNode = curNode.left;
                    }
                }else{
                    if(curNode.right === null){
                        curNode.right = new Node(data);
                        break;
                    }else{
                        curNode = curNode.right;
                    }
                }
            }
        }
    }

    // 插入（使用递归的方式）
    this.insert2 = function(data){
        const insertNode = (node,data)=>{
            if(data < node.data){
                if(node.left === null){
                    node.left = new Node(data);
                }else{
                    insertNode(node.left,data);
                }
            }else{
                if(node.right === null){
                    node.right = new Node(data);
                }else{
                    insertNode(node.right,data);
                }
            }
        }
        if(this._root === null){
            this._root = new Node(data);
        }else{
            insertNode(this._root,data);
        }
        
    }

    // 中序遍历
    this.inOrderTraverse = function(callback){
        const inOrder = (node,callback)=>{
            if(node){
                inOrder(node.left,callback);
                (callback && callback(node));
                inOrder(node.right,callback);
            }
        }
        inOrder(this._root,callback);
    }

    // 前序遍历
    this.preOrderTraverse = function(callback){
        const preOrder = (node,callback)=>{
            if(node){
                (callback && callback(node));
                preOrder(node.left,callback);
                preOrder(node.right,callback);
            }
        }
        preOrder(this._root,callback);
    }

    // 后序遍历
    this.postOrderTraverse = function(callback){
        const postOrder = (node,callback)=>{
            if(node){
                postOrder(node.left,callback);
                postOrder(node.right,callback);
                (callback && callback(node));
            }
        }
        postOrder(this._root,callback);
    }

    // 最小数
    this.min = function(){
        let curNode = this._root;
        while(curNode.left && (curNode = curNode.left));
        return curNode;
    }
    // 最大数
    this.max = function(){
        let curNode = this._root;
        while(curNode.right && (curNode = curNode.right));
        return curNode;
    }
    // 查找
    this.find = function(data){
        let curNode = this._root;
        while(curNode){
            if(curNode.data === data){
                break;
            }else{
                curNode = data < curNode.data ? curNode.left : curNode.right;
            }
        }
        return curNode;
    }
    // 删除
    this.remove = function(data){
        const rm = (node,data)=>{
            if(node === null) return null;
            if(data === node.data){
                if(node.left === null && node.right === null){
                    return null;
                }else if(node.left === null){
                    return node.right;
                }else if(node.right === null){
                    return node.left;
                }else{
                    let minNode = (()=>{
                        let curNode = node.right;
                        while(curNode.left && (curNode = curNode.left));
                        return curNode;
                    })();
                    node.data = minNode.data;
                    node.right = rm(node.right,node.data);
                    return node;
                }
            }else{
                if(data < node.data){
                    node.left = rm(node.left,data);
                }else if(data > node.data){
                    node.right = rm(node.right,data);
                }
                return node;
            }
        }

        this._root = rm(this._root,data);
        return true;
    }

}