js算法练习--二叉树

class Node {
            constructor(key) {
                this.key = key;
                this.left = null;
                this.right = null;
            }
        }

        class BstSearch {
            constructor() {
                this.root = null;

            }
            insert(key) {
                var newNode = new Node(key);
               const inserNode = (node, newNode) => {
                    if (newNode.key < node.key) {
                        if (node.left == null) {
                            node.left = newNode;
                        }
                        else {
                            inserNode(node.left, newNode);
                        }
                    }
                    else {
                        if (node.right == null) {
                            node.right = newNode;
                        }
                        else {
                            inserNode(node.right, newNode);
                        }
                    }
                };
                if (!this.root) {
                    this.root=newNode;
                }
                else{
                    inserNode(this.root,newNode); 
                }
            }
            //中序遍历,从做小到最大访问，左跟又
            inOrderTraverse(callback){
                const inOrderTraverseNOde=(node,callback)=>{
                    if(node!=null){
                        inOrderTraverseNOde(node.left,callback);
                        callback(node.key);
                        inOrderTraverseNOde(node.right,callback);
                    }
                };
                inOrderTraverseNOde(this.root,callback);
            }
            //先序遍历，跟左右
            preOrderTraverse(callback){
                const preOrderTraverseNode=(node,callback)=>{
                    if(node){
                        callback(node.key);
                        preOrderTraverseNode(node.left,callback);
                        preOrderTraverseNode(node.right,callback)
                    }
                };
                preOrderTraverseNode(this.root,callback);
            }
            //后序遍历，左右根
            postOrderTraverse(callback){
                const postOrderTraverseNode=(node,callback)=>{
                    if(node){
                        postOrderTraverseNode(node.left,callback);
                        postOrderTraverseNode(node.right,callback);
                        callback(node.key);
                    }
                };
                postOrderTraverseNode(this.root,callback);
            }
            //最小值
            min(node){
                
                const minNode=(node)=>{return node ?(node.left?minNode(node.left):node):null};
                return minNode(node||this.root);
            }
            //最大值
            max(node){
                const maxNode=(node)=>{return node?(node.right?maxNode(node.right):node):null};
                return maxNode(node||this.root);
            }
            //搜索特定值
            search(value){
                const searchNode=(node,value)=>{
                    
                    if(node){
                        if(node.key==value)
                            return node;
                        else if(node.key<value && node.right){
                            return searchNode(node.right,value);
                        }
                        else if(node.key>value && node.left){
                            return  searchNode(node.left,value);
                        }
                    }
                    else{
                        return null;
                    }
                   
                };
               return searchNode(this.root,value);
            }
            

            //删除
           //如果是页面节点，直接删除
           //如果非页面节点
           //           有right，那么将right的最小值替换该节点，删除最小节点
           //           没有right,那么找left的right的最小值替换该节点，删除最小节点
           Remove(value){
               const RemoveNode=(node,value)=>{
                   debugger;
                   if(!node)
                        return false;
                    if(node.key==value){
                        if(node.left===null && node.right===null){
                            let n=node;
                            node=null;
                            
                            return n;
                        }
                        else  if( node.right){
                            let n=this.min(node.right);
                            node.key=n.key;
                            return RemoveNode(node.right,n.key);
                        }
                        else if(node.left){
                            let n=this.min(node.left);
                            node.key=n.key;
                            return  RemoveNode(node.left,n.key);
                        }
                    }
                    else if(node.key<value && node.right){
                        return RemoveNode(node.right,value);
                    }
                    else if(node.key>value && node.left){
                        return  RemoveNode(node.left,value);
                    }
                    
               };
               return RemoveNode(this.root,value);
           }

        }

        var bst=new BstSearch();
        bst.insert(11);
        bst.insert(7);
        bst.insert(5);
        bst.insert(3);
        bst.insert(9);
        bst.insert(8);
        bst.insert(10);
        bst.insert(13);
        bst.insert(12);
        bst.insert(14);
        bst.insert(20);
        bst.insert(18);
        bst.insert(25);