js实现搜索二叉树与平衡二叉树

1.搜索二叉树

概念：所有树的左子结点都比根结点小，所有的右子结点都比根结点大

2.平衡二叉树

概念：在一棵搜索二叉树中每个节点的左右子树的高度差的绝对值不超过1
平衡二叉树的方法:
1.左旋
2.右旋

代码：

// 搜索二叉树
class BinaryTree{
    constructor(value){
        this.value = value;
        this.left = null;
        this.right = null;
        this.height = 1;
    }
    // 插入节点
    insertNode(val){
        const insert = (node, key)=>{
            if(!node) return null
            if(node.value === null) return node.value = key
            // debugger
            
            if(key < node.value){
                if(node.left === null){
                    node.left = new BinaryTree(key)
                    
                }else{
                    insert(node.left, key)
                }
            }else{
                if(node.right === null){
                    node.right = new BinaryTree(key)
                    
                }else{
                    insert(node.right, key)
                }
            }

            node.height = Math.max(this.getHeight(node.left), this.getHeight(node.right)) + 1;
           
        }
        insert(this, val)
        // 插入完后需要判断是否旋转
        this.rotate(this)
    }
    // 查询节点
    search(val){
        const searchNode = (node, key)=>{
            if(node === null|| !node) return null;
            if(node.value === key) return node;
            if(key < node.value){
                return searchNode(node.left, key)
            }else{
                return searchNode(node.right, key)
            }
        }
        searchNode(this,val)
    }
    // 移除节点
    remove(val){
        const removeNode = (node, key)=>{
            if(node === null) return null;
            if(node.value === key){
                if(node.left === null && node.right === null){
                    return null;
                }
                if(node.left === null){
                    return node.right;
                }
                if(node.right === null){
                    return node.left;
                }
                let tempNode = node.right;
                while(tempNode.left !== null){
                    tempNode = tempNode.left;
                }
                node.value = tempNode.value;
                node.right = removeNode(node.right, tempNode.value)
                
            }
            if(key < node.value){
                const left = removeNode(node.left, key)
                node.left = left
                
            }
            if(key > node.value){
                const right = removeNode(node.right, key)
                node.right = right
            }
           
            return node
        }
        removeNode(this, val)
        this.rotate(this)
    }
    // 旋转
    rotate(lodNode){
        const rotate = (node)=>{
            if(node === null) return 
            const leftHeight = this.getHeight(node.left)
            const rightHeight = this.getHeight(node.right)
            const diffHeight = Math.abs(leftHeight - rightHeight)
            if(diffHeight <= 1) return node
            let newNode = node
            if(leftHeight > rightHeight){
                newNode = this.rotateRight(node)
            }
            if(leftHeight < rightHeight){
                newNode =this.rotateLeft(node)
            }
            node.height = Math.max(this.getHeight(node.left), this.getHeight(node.right)) + 1;
            newNode.left = rotate(newNode.left)
            newNode.right = rotate(newNode.right)
            return newNode;
        }

        const newNode = rotate(lodNode)
        return newNode
    }
    // 右旋
    rotateRight(node){
        if(!node) return
        let leftTree = node.left;
        let rightTree = node.right;
        let nodeValue = node.value;
        node.value = leftTree.value;
        node.left = leftTree.left;
        node.right = new BinaryTree(nodeValue);
        node.right.left = leftTree.right;
        node.right.right = rightTree;
        node.height = Math.max(this.getHeight(node.left), this.getHeight(node.right)) + 1;
        return node
    }
    // 左旋
    rotateLeft(node){
        if(!node) return
        let leftTree = node.left;
        let rightTree = node.right;
        let nodeValue = node.value;
        node.value = rightTree.value;
        node.right = rightTree.right;
        node.left = new BinaryTree(nodeValue);
        node.left.left = leftTree;
        node.left.right = rightTree.left;
        node.height = Math.max(this.getHeight(node.left), this.getHeight(node.right)) + 1;
        return node
    }

    getHeight(node){
        if(node === null||!node) return 0;
        let height = 0;

       const dfs=(node, count)=>{
            if(!node) return 0
            
            let leftHeight = 0
            let rightHeight = 0
            if(node.left !== null){
                leftHeight = dfs(node.left, count)
            }
            if(node.right !== null){
                rightHeight= count+= dfs(node.right, count)
            }
            count = Math.max(leftHeight, rightHeight)+1
            node.height = count
            return count
        }
        height = dfs(node, height)
        return height
    }
   
}


const bt = new BinaryTree(50)
bt.insertNode(30)
bt.insertNode(70)
bt.insertNode(10)
bt.insertNode(40)
bt.insertNode(60)
bt.insertNode(80)
bt.insertNode(90)
bt.insertNode(100)
console.log('bt===tree',bt);